blob: 108fa361d262e9a34b3efdda09709c300de6d752 [file] [log] [blame]
Dave Barach68b0fb02017-02-28 15:15:56 -05001/*
Florin Coras288eaab2019-02-03 15:26:14 -08002 * Copyright (c) 2017-2019 Cisco and/or its affiliates.
Dave Barach68b0fb02017-02-28 15:15:56 -05003 * 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/**
16 * @file
17 * @brief Session and session manager
18 */
19
20#include <vnet/session/session.h>
Florin Coras04e53442017-07-16 17:12:15 -070021#include <vnet/session/application.h>
Dave Barach68b0fb02017-02-28 15:15:56 -050022#include <vnet/dpo/load_balance.h>
23#include <vnet/fib/ip4_fib.h>
Dave Barach68b0fb02017-02-28 15:15:56 -050024
Florin Coras31c99552019-03-01 13:00:58 -080025session_main_t session_main;
Florin Coras3eb50622017-07-13 01:24:57 -040026
Florin Coras3c2fed52018-07-04 04:15:05 -070027static inline int
28session_send_evt_to_thread (void *data, void *args, u32 thread_index,
29 session_evt_type_t evt_type)
Florin Coras3cbc04b2017-10-02 00:18:51 -070030{
Florin Coras7da88292021-03-18 15:04:34 -070031 session_worker_t *wrk = session_main_get_worker (thread_index);
Florin Coras52207f12018-07-12 14:48:06 -070032 session_event_t *evt;
Florin Coras3c2fed52018-07-04 04:15:05 -070033 svm_msg_q_msg_t msg;
34 svm_msg_q_t *mq;
Florin Coras3cbc04b2017-10-02 00:18:51 -070035
Florin Coras7da88292021-03-18 15:04:34 -070036 mq = wrk->vpp_event_queue;
Nathan Skrzypczakb4c67752019-06-20 09:58:37 +020037 if (PREDICT_FALSE (svm_msg_q_lock (mq)))
38 return -1;
Nathan Skrzypczak989bc472019-11-19 16:48:58 +010039 if (PREDICT_FALSE (svm_msg_q_is_full (mq)
40 || svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
Florin Coras3c2fed52018-07-04 04:15:05 -070041 {
42 svm_msg_q_unlock (mq);
43 return -2;
44 }
Florin Coras3c2fed52018-07-04 04:15:05 -070045 switch (evt_type)
46 {
Florin Corasf6c43132019-03-01 12:41:21 -080047 case SESSION_CTRL_EVT_RPC:
Nathan Skrzypczak1afa7af2019-09-13 17:14:57 +020048 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
49 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Coras3c2fed52018-07-04 04:15:05 -070050 evt->rpc_args.fp = data;
51 evt->rpc_args.arg = args;
52 break;
Aloys Augustin0c7f54d2019-07-03 16:59:43 +020053 case SESSION_IO_EVT_RX:
Florin Corasf6c43132019-03-01 12:41:21 -080054 case SESSION_IO_EVT_TX:
Florin Coras844a36d2018-12-20 09:50:50 -080055 case SESSION_IO_EVT_TX_FLUSH:
Florin Corasf6c43132019-03-01 12:41:21 -080056 case SESSION_IO_EVT_BUILTIN_RX:
Nathan Skrzypczak1afa7af2019-09-13 17:14:57 +020057 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
58 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Corasc0737e92019-03-04 14:19:39 -080059 evt->session_index = *(u32 *) data;
Florin Coras3c2fed52018-07-04 04:15:05 -070060 break;
Florin Corasf6c43132019-03-01 12:41:21 -080061 case SESSION_IO_EVT_BUILTIN_TX:
62 case SESSION_CTRL_EVT_CLOSE:
Florin Coras73cad332019-08-28 17:12:32 -070063 case SESSION_CTRL_EVT_RESET:
Nathan Skrzypczak1afa7af2019-09-13 17:14:57 +020064 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
65 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Coras288eaab2019-02-03 15:26:14 -080066 evt->session_handle = session_handle ((session_t *) data);
Florin Coras3c2fed52018-07-04 04:15:05 -070067 break;
68 default:
69 clib_warning ("evt unhandled!");
70 svm_msg_q_unlock (mq);
71 return -1;
72 }
Nathan Skrzypczak1afa7af2019-09-13 17:14:57 +020073 evt->event_type = evt_type;
Florin Coras3c2fed52018-07-04 04:15:05 -070074
Florin Coras52207f12018-07-12 14:48:06 -070075 svm_msg_q_add_and_unlock (mq, &msg);
Florin Coras7da88292021-03-18 15:04:34 -070076
77 if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT))
78 vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index);
79
Florin Coras3c2fed52018-07-04 04:15:05 -070080 return 0;
Florin Coras3cbc04b2017-10-02 00:18:51 -070081}
82
Florin Coras3c2fed52018-07-04 04:15:05 -070083int
84session_send_io_evt_to_thread (svm_fifo_t * f, session_evt_type_t evt_type)
Florin Coras3cbc04b2017-10-02 00:18:51 -070085{
Florin Corasc547e912020-12-08 17:50:45 -080086 return session_send_evt_to_thread (&f->shr->master_session_index, 0,
Florin Corasc0737e92019-03-04 14:19:39 -080087 f->master_thread_index, evt_type);
Florin Coras3c2fed52018-07-04 04:15:05 -070088}
89
90int
Florin Corasef915342018-09-29 10:23:06 -070091session_send_io_evt_to_thread_custom (void *data, u32 thread_index,
Florin Coras3c2fed52018-07-04 04:15:05 -070092 session_evt_type_t evt_type)
93{
Florin Corasef915342018-09-29 10:23:06 -070094 return session_send_evt_to_thread (data, 0, thread_index, evt_type);
Florin Coras3c2fed52018-07-04 04:15:05 -070095}
96
97int
Florin Coras288eaab2019-02-03 15:26:14 -080098session_send_ctrl_evt_to_thread (session_t * s, session_evt_type_t evt_type)
Florin Coras3c2fed52018-07-04 04:15:05 -070099{
liuyacan534468e2021-05-09 03:50:40 +0000100 /* only events supported are disconnect, shutdown and reset */
101 ASSERT (evt_type == SESSION_CTRL_EVT_CLOSE ||
102 evt_type == SESSION_CTRL_EVT_HALF_CLOSE ||
103 evt_type == SESSION_CTRL_EVT_RESET);
Florin Coras458089b2019-08-21 16:20:44 -0700104 return session_send_evt_to_thread (s, 0, s->thread_index, evt_type);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700105}
106
107void
Nathan Skrzypczak60f3e652019-03-19 13:57:31 +0100108session_send_rpc_evt_to_thread_force (u32 thread_index, void *fp,
109 void *rpc_args)
110{
111 session_send_evt_to_thread (fp, rpc_args, thread_index,
112 SESSION_CTRL_EVT_RPC);
113}
114
115void
Florin Coras3cbc04b2017-10-02 00:18:51 -0700116session_send_rpc_evt_to_thread (u32 thread_index, void *fp, void *rpc_args)
117{
118 if (thread_index != vlib_get_thread_index ())
Nathan Skrzypczak60f3e652019-03-19 13:57:31 +0100119 session_send_rpc_evt_to_thread_force (thread_index, fp, rpc_args);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700120 else
121 {
122 void (*fnp) (void *) = fp;
123 fnp (rpc_args);
124 }
125}
126
Florin Coras26dd6de2019-07-23 23:54:47 -0700127void
128session_add_self_custom_tx_evt (transport_connection_t * tc, u8 has_prio)
129{
Florin Coras7da88292021-03-18 15:04:34 -0700130 session_t *s = session_get (tc->s_index, tc->thread_index);
Florin Coras26dd6de2019-07-23 23:54:47 -0700131
Florin Coras26dd6de2019-07-23 23:54:47 -0700132 ASSERT (s->thread_index == vlib_get_thread_index ());
Florin Corasbe237bf2019-09-27 08:16:40 -0700133 ASSERT (s->session_state != SESSION_STATE_TRANSPORT_DELETED);
Florin Coras7da88292021-03-18 15:04:34 -0700134
Florin Coras26dd6de2019-07-23 23:54:47 -0700135 if (!(s->flags & SESSION_F_CUSTOM_TX))
136 {
137 s->flags |= SESSION_F_CUSTOM_TX;
Florin Coras6080e0d2020-03-13 20:39:43 +0000138 if (svm_fifo_set_event (s->tx_fifo)
139 || transport_connection_is_descheduled (tc))
Florin Coras26dd6de2019-07-23 23:54:47 -0700140 {
Florin Coras26dd6de2019-07-23 23:54:47 -0700141 session_evt_elt_t *elt;
Florin Coras7da88292021-03-18 15:04:34 -0700142 session_worker_t *wrk;
143
Florin Coras26dd6de2019-07-23 23:54:47 -0700144 wrk = session_main_get_worker (tc->thread_index);
145 if (has_prio)
146 elt = session_evt_alloc_new (wrk);
147 else
148 elt = session_evt_alloc_old (wrk);
149 elt->evt.session_index = tc->s_index;
150 elt->evt.event_type = SESSION_IO_EVT_TX;
Florin Coras6080e0d2020-03-13 20:39:43 +0000151 tc->flags &= ~TRANSPORT_CONNECTION_F_DESCHED;
Florin Coras7da88292021-03-18 15:04:34 -0700152
153 if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT))
154 vlib_node_set_interrupt_pending (wrk->vm,
155 session_queue_node.index);
Florin Coras26dd6de2019-07-23 23:54:47 -0700156 }
157 }
158}
159
Florin Coras70f879d2020-03-13 17:54:42 +0000160void
161sesssion_reschedule_tx (transport_connection_t * tc)
162{
163 session_worker_t *wrk = session_main_get_worker (tc->thread_index);
164 session_evt_elt_t *elt;
165
166 ASSERT (tc->thread_index == vlib_get_thread_index ());
167
168 elt = session_evt_alloc_new (wrk);
169 elt->evt.session_index = tc->s_index;
170 elt->evt.event_type = SESSION_IO_EVT_TX;
Florin Coras7da88292021-03-18 15:04:34 -0700171
172 if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT))
173 vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index);
Florin Coras70f879d2020-03-13 17:54:42 +0000174}
175
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800176static void
Florin Corasdfb3b872019-08-16 17:48:44 -0700177session_program_transport_ctrl_evt (session_t * s, session_evt_type_t evt)
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800178{
179 u32 thread_index = vlib_get_thread_index ();
Florin Coras2062ec02019-07-15 13:15:18 -0700180 session_evt_elt_t *elt;
Florin Coras31c99552019-03-01 13:00:58 -0800181 session_worker_t *wrk;
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800182
183 /* If we are in the handler thread, or being called with the worker barrier
184 * held, just append a new event to pending disconnects vector. */
185 if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index)
186 {
Florin Coras31c99552019-03-01 13:00:58 -0800187 wrk = session_main_get_worker (s->thread_index);
Florin Corasb0ffbee2019-07-21 19:23:46 -0700188 elt = session_evt_alloc_ctrl (wrk);
Florin Coras2062ec02019-07-15 13:15:18 -0700189 clib_memset (&elt->evt, 0, sizeof (session_event_t));
190 elt->evt.session_handle = session_handle (s);
Florin Corasdfb3b872019-08-16 17:48:44 -0700191 elt->evt.event_type = evt;
Florin Coras7da88292021-03-18 15:04:34 -0700192
193 if (PREDICT_FALSE (wrk->state == SESSION_WRK_INTERRUPT))
194 vlib_node_set_interrupt_pending (wrk->vm, session_queue_node.index);
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800195 }
196 else
Florin Corasdfb3b872019-08-16 17:48:44 -0700197 session_send_ctrl_evt_to_thread (s, evt);
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800198}
199
Florin Coras288eaab2019-02-03 15:26:14 -0800200session_t *
Florin Coras3cbc04b2017-10-02 00:18:51 -0700201session_alloc (u32 thread_index)
Dave Barach68b0fb02017-02-28 15:15:56 -0500202{
Florin Coras31c99552019-03-01 13:00:58 -0800203 session_worker_t *wrk = &session_main.wrk[thread_index];
Florin Coras288eaab2019-02-03 15:26:14 -0800204 session_t *s;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700205 u8 will_expand = 0;
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700206 pool_get_aligned_will_expand (wrk->sessions, will_expand,
Florin Coras3cbc04b2017-10-02 00:18:51 -0700207 CLIB_CACHE_LINE_BYTES);
208 /* If we have peekers, let them finish */
Florin Coras84a30ef2018-01-24 10:49:23 -0800209 if (PREDICT_FALSE (will_expand && vlib_num_workers ()))
Florin Coras3cbc04b2017-10-02 00:18:51 -0700210 {
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700211 clib_rwlock_writer_lock (&wrk->peekers_rw_locks);
212 pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES);
213 clib_rwlock_writer_unlock (&wrk->peekers_rw_locks);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700214 }
215 else
216 {
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700217 pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700218 }
Dave Barachb7b92992018-10-17 10:38:51 -0400219 clib_memset (s, 0, sizeof (*s));
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700220 s->session_index = s - wrk->sessions;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700221 s->thread_index = thread_index;
Nathan Skrzypczak2f0f96b2019-06-13 10:14:28 +0200222 s->app_index = APP_INVALID_INDEX;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700223 return s;
224}
225
Florin Coras371ca502018-02-21 12:07:41 -0800226void
Florin Coras288eaab2019-02-03 15:26:14 -0800227session_free (session_t * s)
Florin Coras3cbc04b2017-10-02 00:18:51 -0700228{
Florin Coras3cbc04b2017-10-02 00:18:51 -0700229 if (CLIB_DEBUG)
Florin Coras6416e622019-04-03 17:52:43 -0700230 {
231 u8 thread_index = s->thread_index;
232 clib_memset (s, 0xFA, sizeof (*s));
233 pool_put (session_main.wrk[thread_index].sessions, s);
234 return;
235 }
Florin Corascca96182019-07-19 07:34:13 -0700236 SESSION_EVT (SESSION_EVT_FREE, s);
Florin Coras6416e622019-04-03 17:52:43 -0700237 pool_put (session_main.wrk[s->thread_index].sessions, s);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700238}
239
Srikanth Akulae140d5d2019-11-18 11:49:58 -0800240u8
241session_is_valid (u32 si, u8 thread_index)
242{
243 session_t *s;
244 transport_connection_t *tc;
245
246 s = pool_elt_at_index (session_main.wrk[thread_index].sessions, si);
247
Srikanth Akulae140d5d2019-11-18 11:49:58 -0800248 if (s->thread_index != thread_index || s->session_index != si)
249 return 0;
250
251 if (s->session_state == SESSION_STATE_TRANSPORT_DELETED
252 || s->session_state <= SESSION_STATE_LISTENING)
253 return 1;
254
Florin Corasea727642021-05-07 19:39:43 -0700255 if (s->session_state == SESSION_STATE_CONNECTING &&
256 (s->flags & SESSION_F_HALF_OPEN))
257 return 1;
258
Srikanth Akulae140d5d2019-11-18 11:49:58 -0800259 tc = session_get_transport (s);
260 if (s->connection_index != tc->c_index
261 || s->thread_index != tc->thread_index || tc->s_index != si)
262 return 0;
263
264 return 1;
265}
266
Florin Coras70f26d52019-07-08 11:47:18 -0700267static void
268session_cleanup_notify (session_t * s, session_cleanup_ntf_t ntf)
269{
270 app_worker_t *app_wrk;
271
272 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
273 if (!app_wrk)
274 return;
275 app_worker_cleanup_notify (app_wrk, s, ntf);
276}
277
Florin Coraseb97e5f2018-10-15 21:35:42 -0700278void
Florin Coras288eaab2019-02-03 15:26:14 -0800279session_free_w_fifos (session_t * s)
Florin Coras568ebc72018-09-18 16:12:50 -0700280{
Florin Coras70f26d52019-07-08 11:47:18 -0700281 session_cleanup_notify (s, SESSION_CLEANUP_SESSION);
Florin Coras19223e02019-03-03 14:56:05 -0800282 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
Florin Coras568ebc72018-09-18 16:12:50 -0700283 session_free (s);
284}
285
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800286/**
287 * Cleans up session and lookup table.
288 *
289 * Transport connection must still be valid.
290 */
291static void
Florin Coras288eaab2019-02-03 15:26:14 -0800292session_delete (session_t * s)
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800293{
294 int rv;
295
296 /* Delete from the main lookup table. */
297 if ((rv = session_lookup_del_session (s)))
Florin Corasd09236d2019-08-08 17:38:26 -0700298 clib_warning ("session %u hash delete rv %d", s->session_index, rv);
Florin Coras5a2ec8f2018-12-27 11:53:11 -0800299
300 session_free_w_fifos (s);
301}
302
Florin Corasd50ff7f2020-04-16 04:30:22 +0000303void
Florin Corasea727642021-05-07 19:39:43 -0700304session_cleanup_half_open (session_handle_t ho_handle)
Florin Corasd50ff7f2020-04-16 04:30:22 +0000305{
Florin Corasbab6c522021-05-13 08:36:56 -0700306 session_t *ho = session_get_from_handle (ho_handle);
307
308 /* App transports can migrate their half-opens */
309 if (ho->flags & SESSION_F_IS_MIGRATING)
310 {
311 /* Session still migrating, move to closed state to signal that the
312 * session should be removed. */
313 if (ho->connection_index == ~0)
314 {
315 ho->session_state = SESSION_STATE_CLOSED;
316 return;
317 }
318 /* Migrated transports are no longer half-opens */
319 transport_cleanup (session_get_transport_proto (ho),
320 ho->connection_index, ho->app_index /* overloaded */);
Florin Corasbab6c522021-05-13 08:36:56 -0700321 }
Florin Coras374df7a2021-05-13 11:37:43 -0700322 else
323 transport_cleanup_half_open (session_get_transport_proto (ho),
324 ho->connection_index);
325 session_free (ho);
Florin Corasbab6c522021-05-13 08:36:56 -0700326}
327
328static void
Florin Coras374df7a2021-05-13 11:37:43 -0700329session_half_open_free (session_t *ho)
Florin Corasbab6c522021-05-13 08:36:56 -0700330{
331 app_worker_t *app_wrk;
Florin Corasbab6c522021-05-13 08:36:56 -0700332
333 ASSERT (vlib_get_thread_index () <= 1);
Florin Corasbab6c522021-05-13 08:36:56 -0700334 app_wrk = app_worker_get (ho->app_wrk_index);
335 app_worker_del_half_open (app_wrk, ho);
336 session_free (ho);
337}
338
339static void
340session_half_open_free_rpc (void *args)
341{
Florin Coras374df7a2021-05-13 11:37:43 -0700342 session_t *ho = ho_session_get (pointer_to_uword (args));
343 session_half_open_free (ho);
Florin Corasd50ff7f2020-04-16 04:30:22 +0000344}
345
346void
Florin Corasea727642021-05-07 19:39:43 -0700347session_half_open_delete_notify (transport_connection_t *tc)
Florin Corasd50ff7f2020-04-16 04:30:22 +0000348{
Florin Coras374df7a2021-05-13 11:37:43 -0700349 /* Notification from ctrl thread accepted without rpc */
Florin Coras6bd54ca2021-06-10 22:50:26 -0700350 if (!tc->thread_index)
Florin Coras374df7a2021-05-13 11:37:43 -0700351 {
352 session_half_open_free (ho_session_get (tc->s_index));
353 }
354 else
355 {
356 void *args = uword_to_pointer ((uword) tc->s_index, void *);
Florin Coras6bd54ca2021-06-10 22:50:26 -0700357 session_send_rpc_evt_to_thread_force (0, session_half_open_free_rpc,
358 args);
Florin Coras374df7a2021-05-13 11:37:43 -0700359 }
Florin Corasbab6c522021-05-13 08:36:56 -0700360}
Florin Corasea727642021-05-07 19:39:43 -0700361
Florin Corasbab6c522021-05-13 08:36:56 -0700362void
363session_half_open_migrate_notify (transport_connection_t *tc)
364{
365 session_t *ho;
366
367 ho = ho_session_get (tc->s_index);
368 ho->flags |= SESSION_F_IS_MIGRATING;
369 ho->connection_index = ~0;
370}
371
372int
373session_half_open_migrated_notify (transport_connection_t *tc)
374{
375 session_t *ho;
376
377 ho = ho_session_get (tc->s_index);
378
379 /* App probably detached so the half-open must be cleaned up */
380 if (ho->session_state == SESSION_STATE_CLOSED)
381 {
382 session_half_open_delete_notify (tc);
383 return -1;
384 }
385 ho->connection_index = tc->c_index;
386 /* Overload app index for half-open with new thread */
387 ho->app_index = tc->thread_index;
388 return 0;
Florin Corasd50ff7f2020-04-16 04:30:22 +0000389}
390
Andreas Schultz1a8c4372020-03-20 09:39:59 +0100391session_t *
Florin Coras3cbc04b2017-10-02 00:18:51 -0700392session_alloc_for_connection (transport_connection_t * tc)
393{
Florin Coras288eaab2019-02-03 15:26:14 -0800394 session_t *s;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700395 u32 thread_index = tc->thread_index;
396
Florin Coras40903ac2018-06-10 14:41:23 -0700397 ASSERT (thread_index == vlib_get_thread_index ()
398 || transport_protocol_is_cl (tc->proto));
Dave Barach2c25a622017-06-26 11:35:07 -0400399
Florin Coras3cbc04b2017-10-02 00:18:51 -0700400 s = session_alloc (thread_index);
401 s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4);
Florin Corasb0f662f2018-12-27 14:51:46 -0800402 s->session_state = SESSION_STATE_CLOSED;
Dave Barach68b0fb02017-02-28 15:15:56 -0500403
Florin Coras3cbc04b2017-10-02 00:18:51 -0700404 /* Attach transport to session and vice versa */
Dave Barach68b0fb02017-02-28 15:15:56 -0500405 s->connection_index = tc->c_index;
Dave Barach68b0fb02017-02-28 15:15:56 -0500406 tc->s_index = s->session_index;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700407 return s;
408}
409
Florin Coras2c876f92021-05-10 21:12:27 -0700410session_t *
Florin Corasea727642021-05-07 19:39:43 -0700411session_alloc_for_half_open (transport_connection_t *tc)
412{
413 session_t *s;
414
415 s = ho_session_alloc ();
416 s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4);
417 s->connection_index = tc->c_index;
418 tc->s_index = s->session_index;
419 return s;
420}
421
Florin Coras1f152cd2017-08-18 19:28:03 -0700422/**
423 * Discards bytes from buffer chain
424 *
425 * It discards n_bytes_to_drop starting at first buffer after chain_b
426 */
427always_inline void
428session_enqueue_discard_chain_bytes (vlib_main_t * vm, vlib_buffer_t * b,
429 vlib_buffer_t ** chain_b,
430 u32 n_bytes_to_drop)
431{
432 vlib_buffer_t *next = *chain_b;
433 u32 to_drop = n_bytes_to_drop;
434 ASSERT (b->flags & VLIB_BUFFER_NEXT_PRESENT);
435 while (to_drop && (next->flags & VLIB_BUFFER_NEXT_PRESENT))
436 {
437 next = vlib_get_buffer (vm, next->next_buffer);
438 if (next->current_length > to_drop)
439 {
440 vlib_buffer_advance (next, to_drop);
441 to_drop = 0;
442 }
443 else
444 {
445 to_drop -= next->current_length;
446 next->current_length = 0;
447 }
448 }
449 *chain_b = next;
450
451 if (to_drop == 0)
452 b->total_length_not_including_first_buffer -= n_bytes_to_drop;
453}
454
455/**
456 * Enqueue buffer chain tail
457 */
Florin Corasf6d68ed2017-05-07 19:12:02 -0700458always_inline int
Florin Coras288eaab2019-02-03 15:26:14 -0800459session_enqueue_chain_tail (session_t * s, vlib_buffer_t * b,
Florin Corasf6d68ed2017-05-07 19:12:02 -0700460 u32 offset, u8 is_in_order)
461{
462 vlib_buffer_t *chain_b;
Florin Coras1f152cd2017-08-18 19:28:03 -0700463 u32 chain_bi, len, diff;
Florin Corasf6d68ed2017-05-07 19:12:02 -0700464 vlib_main_t *vm = vlib_get_main ();
Florin Corasb2215d62017-08-01 16:56:58 -0700465 u8 *data;
Florin Coras1f152cd2017-08-18 19:28:03 -0700466 u32 written = 0;
Florin Corasf6d68ed2017-05-07 19:12:02 -0700467 int rv = 0;
468
Florin Coras1f152cd2017-08-18 19:28:03 -0700469 if (is_in_order && offset)
470 {
471 diff = offset - b->current_length;
472 if (diff > b->total_length_not_including_first_buffer)
473 return 0;
474 chain_b = b;
475 session_enqueue_discard_chain_bytes (vm, b, &chain_b, diff);
476 chain_bi = vlib_get_buffer_index (vm, chain_b);
477 }
478 else
479 chain_bi = b->next_buffer;
480
Florin Corasf6d68ed2017-05-07 19:12:02 -0700481 do
482 {
483 chain_b = vlib_get_buffer (vm, chain_bi);
484 data = vlib_buffer_get_current (chain_b);
485 len = chain_b->current_length;
Florin Coras1f152cd2017-08-18 19:28:03 -0700486 if (!len)
487 continue;
Florin Corasf6d68ed2017-05-07 19:12:02 -0700488 if (is_in_order)
489 {
Florin Coras87b15ce2019-04-28 21:16:30 -0700490 rv = svm_fifo_enqueue (s->rx_fifo, len, data);
Florin Coras1f152cd2017-08-18 19:28:03 -0700491 if (rv == len)
492 {
493 written += rv;
494 }
495 else if (rv < len)
Florin Corasf6d68ed2017-05-07 19:12:02 -0700496 {
497 return (rv > 0) ? (written + rv) : written;
498 }
Florin Coras1f152cd2017-08-18 19:28:03 -0700499 else if (rv > len)
500 {
501 written += rv;
502
503 /* written more than what was left in chain */
504 if (written > b->total_length_not_including_first_buffer)
505 return written;
506
507 /* drop the bytes that have already been delivered */
508 session_enqueue_discard_chain_bytes (vm, b, &chain_b, rv - len);
509 }
Florin Corasf6d68ed2017-05-07 19:12:02 -0700510 }
511 else
512 {
Florin Coras288eaab2019-02-03 15:26:14 -0800513 rv = svm_fifo_enqueue_with_offset (s->rx_fifo, offset, len, data);
Florin Corasf6d68ed2017-05-07 19:12:02 -0700514 if (rv)
Florin Coras1f152cd2017-08-18 19:28:03 -0700515 {
516 clib_warning ("failed to enqueue multi-buffer seg");
517 return -1;
518 }
Florin Corasf6d68ed2017-05-07 19:12:02 -0700519 offset += len;
520 }
521 }
522 while ((chain_bi = (chain_b->flags & VLIB_BUFFER_NEXT_PRESENT)
523 ? chain_b->next_buffer : 0));
524
525 if (is_in_order)
526 return written;
527
528 return 0;
529}
530
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000531void
532session_fifo_tuning (session_t * s, svm_fifo_t * f,
533 session_ft_action_t act, u32 len)
534{
535 if (s->flags & SESSION_F_CUSTOM_FIFO_TUNING)
536 {
537 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
538 app_worker_session_fifo_tuning (app_wrk, s, f, act, len);
539 if (CLIB_ASSERT_ENABLE)
540 {
541 segment_manager_t *sm;
542 sm = segment_manager_get (f->segment_manager);
Florin Corasc547e912020-12-08 17:50:45 -0800543 ASSERT (f->shr->size >= 4096);
544 ASSERT (f->shr->size <= sm->max_fifo_size);
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000545 }
546 }
547}
548
Dave Barach68b0fb02017-02-28 15:15:56 -0500549/*
550 * Enqueue data for delivery to session peer. Does not notify peer of enqueue
551 * event but on request can queue notification events for later delivery by
552 * calling stream_server_flush_enqueue_events().
553 *
554 * @param tc Transport connection which is to be enqueued data
Florin Corasf6d68ed2017-05-07 19:12:02 -0700555 * @param b Buffer to be enqueued
556 * @param offset Offset at which to start enqueueing if out-of-order
Dave Barach68b0fb02017-02-28 15:15:56 -0500557 * @param queue_event Flag to indicate if peer is to be notified or if event
558 * is to be queued. The former is useful when more data is
559 * enqueued and only one event is to be generated.
Florin Corasf6d68ed2017-05-07 19:12:02 -0700560 * @param is_in_order Flag to indicate if data is in order
Dave Barach68b0fb02017-02-28 15:15:56 -0500561 * @return Number of bytes enqueued or a negative value if enqueueing failed.
562 */
563int
Florin Coras3cbc04b2017-10-02 00:18:51 -0700564session_enqueue_stream_connection (transport_connection_t * tc,
565 vlib_buffer_t * b, u32 offset,
566 u8 queue_event, u8 is_in_order)
Dave Barach68b0fb02017-02-28 15:15:56 -0500567{
Florin Coras288eaab2019-02-03 15:26:14 -0800568 session_t *s;
Florin Coras1f152cd2017-08-18 19:28:03 -0700569 int enqueued = 0, rv, in_order_off;
Dave Barach68b0fb02017-02-28 15:15:56 -0500570
Florin Corascea194d2017-10-02 00:18:51 -0700571 s = session_get (tc->s_index, tc->thread_index);
Dave Barach68b0fb02017-02-28 15:15:56 -0500572
Florin Corasf6d68ed2017-05-07 19:12:02 -0700573 if (is_in_order)
574 {
Florin Coras87b15ce2019-04-28 21:16:30 -0700575 enqueued = svm_fifo_enqueue (s->rx_fifo,
576 b->current_length,
577 vlib_buffer_get_current (b));
Florin Coras1f152cd2017-08-18 19:28:03 -0700578 if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT)
579 && enqueued >= 0))
Florin Corasf6d68ed2017-05-07 19:12:02 -0700580 {
Florin Coras1f152cd2017-08-18 19:28:03 -0700581 in_order_off = enqueued > b->current_length ? enqueued : 0;
582 rv = session_enqueue_chain_tail (s, b, in_order_off, 1);
583 if (rv > 0)
584 enqueued += rv;
Florin Corasf6d68ed2017-05-07 19:12:02 -0700585 }
586 }
587 else
588 {
Florin Coras288eaab2019-02-03 15:26:14 -0800589 rv = svm_fifo_enqueue_with_offset (s->rx_fifo, offset,
Florin Corasf6d68ed2017-05-07 19:12:02 -0700590 b->current_length,
591 vlib_buffer_get_current (b));
592 if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) && !rv))
Florin Coras1f152cd2017-08-18 19:28:03 -0700593 session_enqueue_chain_tail (s, b, offset + b->current_length, 0);
594 /* if something was enqueued, report even this as success for ooo
595 * segment handling */
596 return rv;
Florin Corasf6d68ed2017-05-07 19:12:02 -0700597 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500598
599 if (queue_event)
600 {
601 /* Queue RX event on this fifo. Eventually these will need to be flushed
602 * by calling stream_server_flush_enqueue_events () */
Florin Coras31c99552019-03-01 13:00:58 -0800603 session_worker_t *wrk;
Dave Barach68b0fb02017-02-28 15:15:56 -0500604
Florin Coras31c99552019-03-01 13:00:58 -0800605 wrk = session_main_get_worker (s->thread_index);
Florin Corasd5c604d2019-03-18 09:06:35 -0700606 if (!(s->flags & SESSION_F_RX_EVT))
Dave Barach68b0fb02017-02-28 15:15:56 -0500607 {
Florin Corasd5c604d2019-03-18 09:06:35 -0700608 s->flags |= SESSION_F_RX_EVT;
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700609 vec_add1 (wrk->session_to_enqueue[tc->proto], s->session_index);
Dave Barach68b0fb02017-02-28 15:15:56 -0500610 }
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000611
612 session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED, 0);
Dave Barach68b0fb02017-02-28 15:15:56 -0500613 }
614
Chris Lukeb2bcad62017-09-18 08:51:22 -0400615 return enqueued;
Dave Barach68b0fb02017-02-28 15:15:56 -0500616}
617
Florin Coras3cbc04b2017-10-02 00:18:51 -0700618int
Florin Coras288eaab2019-02-03 15:26:14 -0800619session_enqueue_dgram_connection (session_t * s,
Florin Coras7fb0fe12018-04-09 09:24:52 -0700620 session_dgram_hdr_t * hdr,
621 vlib_buffer_t * b, u8 proto, u8 queue_event)
Florin Coras3cbc04b2017-10-02 00:18:51 -0700622{
Florin Corasc95cfa22020-11-24 08:41:17 -0800623 int rv;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700624
Sirshak Das28aa5392019-02-05 01:33:33 -0600625 ASSERT (svm_fifo_max_enqueue_prod (s->rx_fifo)
Florin Coras7fb0fe12018-04-09 09:24:52 -0700626 >= b->current_length + sizeof (*hdr));
627
Florin Corasc95cfa22020-11-24 08:41:17 -0800628 if (PREDICT_TRUE (!(b->flags & VLIB_BUFFER_NEXT_PRESENT)))
Florin Coras3cbc04b2017-10-02 00:18:51 -0700629 {
Florin Corasc95cfa22020-11-24 08:41:17 -0800630 /* *INDENT-OFF* */
631 svm_fifo_seg_t segs[2] = {
632 { (u8 *) hdr, sizeof (*hdr) },
633 { vlib_buffer_get_current (b), b->current_length }
634 };
635 /* *INDENT-ON* */
636
637 rv = svm_fifo_enqueue_segments (s->rx_fifo, segs, 2,
638 0 /* allow_partial */ );
Florin Coras3cbc04b2017-10-02 00:18:51 -0700639 }
Florin Corasc95cfa22020-11-24 08:41:17 -0800640 else
641 {
642 vlib_main_t *vm = vlib_get_main ();
643 svm_fifo_seg_t *segs = 0, *seg;
644 vlib_buffer_t *it = b;
645 u32 n_segs = 1;
646
647 vec_add2 (segs, seg, 1);
648 seg->data = (u8 *) hdr;
649 seg->len = sizeof (*hdr);
650 while (it)
651 {
652 vec_add2 (segs, seg, 1);
653 seg->data = vlib_buffer_get_current (it);
654 seg->len = it->current_length;
655 n_segs++;
656 if (!(it->flags & VLIB_BUFFER_NEXT_PRESENT))
657 break;
658 it = vlib_get_buffer (vm, it->next_buffer);
659 }
660 rv = svm_fifo_enqueue_segments (s->rx_fifo, segs, n_segs,
661 0 /* allow partial */ );
662 vec_free (segs);
663 }
664
665 if (queue_event && rv > 0)
Florin Coras3cbc04b2017-10-02 00:18:51 -0700666 {
667 /* Queue RX event on this fifo. Eventually these will need to be flushed
668 * by calling stream_server_flush_enqueue_events () */
Florin Coras31c99552019-03-01 13:00:58 -0800669 session_worker_t *wrk;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700670
Florin Coras31c99552019-03-01 13:00:58 -0800671 wrk = session_main_get_worker (s->thread_index);
Florin Corasd5c604d2019-03-18 09:06:35 -0700672 if (!(s->flags & SESSION_F_RX_EVT))
Florin Coras3cbc04b2017-10-02 00:18:51 -0700673 {
Florin Corasd5c604d2019-03-18 09:06:35 -0700674 s->flags |= SESSION_F_RX_EVT;
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700675 vec_add1 (wrk->session_to_enqueue[proto], s->session_index);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700676 }
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000677
678 session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED, 0);
Florin Coras3cbc04b2017-10-02 00:18:51 -0700679 }
Florin Corasc95cfa22020-11-24 08:41:17 -0800680 return rv > 0 ? rv : 0;
Florin Coras3cbc04b2017-10-02 00:18:51 -0700681}
682
Florin Coras93992a92017-05-24 18:03:56 -0700683int
Florin Coras31c99552019-03-01 13:00:58 -0800684session_tx_fifo_peek_bytes (transport_connection_t * tc, u8 * buffer,
685 u32 offset, u32 max_bytes)
Dave Barach68b0fb02017-02-28 15:15:56 -0500686{
Florin Coras288eaab2019-02-03 15:26:14 -0800687 session_t *s = session_get (tc->s_index, tc->thread_index);
688 return svm_fifo_peek (s->tx_fifo, offset, max_bytes, buffer);
Dave Barach68b0fb02017-02-28 15:15:56 -0500689}
690
691u32
Florin Coras31c99552019-03-01 13:00:58 -0800692session_tx_fifo_dequeue_drop (transport_connection_t * tc, u32 max_bytes)
Dave Barach68b0fb02017-02-28 15:15:56 -0500693{
Florin Coras288eaab2019-02-03 15:26:14 -0800694 session_t *s = session_get (tc->s_index, tc->thread_index);
Vladimir Kropylevf867cf12019-06-17 21:38:00 +0300695 u32 rv;
696
697 rv = svm_fifo_dequeue_drop (s->tx_fifo, max_bytes);
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000698 session_fifo_tuning (s, s->tx_fifo, SESSION_FT_ACTION_DEQUEUED, rv);
Florin Coras0e573f52019-05-07 16:28:16 -0700699
Florin Coras2d379d82019-06-28 12:45:12 -0700700 if (svm_fifo_needs_deq_ntf (s->tx_fifo, max_bytes))
Florin Coras0e573f52019-05-07 16:28:16 -0700701 session_dequeue_notify (s);
702
Vladimir Kropylevf867cf12019-06-17 21:38:00 +0300703 return rv;
Dave Barach68b0fb02017-02-28 15:15:56 -0500704}
705
Florin Coras72b04282019-01-14 17:23:11 -0800706static inline int
Florin Coras288eaab2019-02-03 15:26:14 -0800707session_notify_subscribers (u32 app_index, session_t * s,
Florin Coras72b04282019-01-14 17:23:11 -0800708 svm_fifo_t * f, session_evt_type_t evt_type)
709{
710 app_worker_t *app_wrk;
711 application_t *app;
712 int i;
713
714 app = application_get (app_index);
715 if (!app)
716 return -1;
717
Florin Corasc547e912020-12-08 17:50:45 -0800718 for (i = 0; i < f->shr->n_subscribers; i++)
Florin Coras72b04282019-01-14 17:23:11 -0800719 {
Florin Corasc547e912020-12-08 17:50:45 -0800720 app_wrk = application_get_worker (app, f->shr->subscribers[i]);
Florin Coras72b04282019-01-14 17:23:11 -0800721 if (!app_wrk)
722 continue;
723 if (app_worker_lock_and_send_event (app_wrk, s, evt_type))
724 return -1;
725 }
726
727 return 0;
728}
729
Dave Barach68b0fb02017-02-28 15:15:56 -0500730/**
731 * Notify session peer that new data has been enqueued.
732 *
Florin Coras3c2fed52018-07-04 04:15:05 -0700733 * @param s Stream session for which the event is to be generated.
734 * @param lock Flag to indicate if call should lock message queue.
Dave Barach68b0fb02017-02-28 15:15:56 -0500735 *
Florin Coras3c2fed52018-07-04 04:15:05 -0700736 * @return 0 on success or negative number if failed to send notification.
Dave Barach68b0fb02017-02-28 15:15:56 -0500737 */
Florin Coras3c2fed52018-07-04 04:15:05 -0700738static inline int
Florin Coras653e43f2019-03-04 10:56:23 -0800739session_enqueue_notify_inline (session_t * s)
Dave Barach68b0fb02017-02-28 15:15:56 -0500740{
Florin Coras72b04282019-01-14 17:23:11 -0800741 app_worker_t *app_wrk;
Aloys Augustinb3b267c2019-04-09 11:25:56 +0200742 u32 session_index;
743 u8 n_subscribers;
744
745 session_index = s->session_index;
746 n_subscribers = svm_fifo_n_subscribers (s->rx_fifo);
Dave Barach68b0fb02017-02-28 15:15:56 -0500747
Florin Coras72b04282019-01-14 17:23:11 -0800748 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
749 if (PREDICT_FALSE (!app_wrk))
Dave Barach818eb542017-08-02 13:56:13 -0400750 {
Florin Coras15531972018-08-12 23:50:53 -0700751 SESSION_DBG ("invalid s->app_index = %d", s->app_wrk_index);
Dave Barach818eb542017-08-02 13:56:13 -0400752 return 0;
753 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500754
Florin Corascca96182019-07-19 07:34:13 -0700755 SESSION_EVT (SESSION_EVT_ENQ, s, svm_fifo_max_dequeue_prod (s->rx_fifo));
Dave Barach68b0fb02017-02-28 15:15:56 -0500756
Florin Corasd5c604d2019-03-18 09:06:35 -0700757 s->flags &= ~SESSION_F_RX_EVT;
Florin Corasda302e42020-04-19 22:41:55 +0000758
759 /* Application didn't confirm accept yet */
760 if (PREDICT_FALSE (s->session_state == SESSION_STATE_ACCEPTING))
761 return 0;
762
Florin Coras72b04282019-01-14 17:23:11 -0800763 if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s,
Florin Corasf6c43132019-03-01 12:41:21 -0800764 SESSION_IO_EVT_RX)))
Florin Coras72b04282019-01-14 17:23:11 -0800765 return -1;
766
Aloys Augustinb3b267c2019-04-09 11:25:56 +0200767 if (PREDICT_FALSE (n_subscribers))
768 {
769 s = session_get (session_index, vlib_get_thread_index ());
770 return session_notify_subscribers (app_wrk->app_index, s,
771 s->rx_fifo, SESSION_IO_EVT_RX);
772 }
Florin Coras72b04282019-01-14 17:23:11 -0800773
774 return 0;
Dave Barach68b0fb02017-02-28 15:15:56 -0500775}
776
Florin Coras0d60a0f2018-06-29 02:02:08 -0700777int
Florin Coras653e43f2019-03-04 10:56:23 -0800778session_enqueue_notify (session_t * s)
779{
780 return session_enqueue_notify_inline (s);
781}
782
Aloys Augustinb3392332019-08-06 16:09:01 +0200783static void
784session_enqueue_notify_rpc (void *arg)
785{
Florin Coras5d8a8062019-08-13 08:35:39 -0700786 u32 session_index = pointer_to_uword (arg);
Aloys Augustinb3392332019-08-06 16:09:01 +0200787 session_t *s;
788
Florin Coras5d8a8062019-08-13 08:35:39 -0700789 s = session_get_if_valid (session_index, vlib_get_thread_index ());
Aloys Augustinb3392332019-08-06 16:09:01 +0200790 if (!s)
791 return;
792
793 session_enqueue_notify (s);
794}
795
796/**
797 * Like session_enqueue_notify, but can be called from a thread that does not
798 * own the session.
799 */
800void
801session_enqueue_notify_thread (session_handle_t sh)
802{
803 u32 thread_index = session_thread_from_handle (sh);
Florin Coras5d8a8062019-08-13 08:35:39 -0700804 u32 session_index = session_index_from_handle (sh);
805
806 /*
807 * Pass session index (u32) as opposed to handle (u64) in case pointers
808 * are not 64-bit.
809 */
Aloys Augustinb3392332019-08-06 16:09:01 +0200810 session_send_rpc_evt_to_thread (thread_index,
Florin Coras5d8a8062019-08-13 08:35:39 -0700811 session_enqueue_notify_rpc,
812 uword_to_pointer (session_index, void *));
Aloys Augustinb3392332019-08-06 16:09:01 +0200813}
814
Florin Coras653e43f2019-03-04 10:56:23 -0800815int
Florin Coras288eaab2019-02-03 15:26:14 -0800816session_dequeue_notify (session_t * s)
Florin Coras0d60a0f2018-06-29 02:02:08 -0700817{
Florin Coras72b04282019-01-14 17:23:11 -0800818 app_worker_t *app_wrk;
Florin Coras0d60a0f2018-06-29 02:02:08 -0700819
Vladimir Kropylev5c89fbf2019-08-30 13:04:06 +0300820 svm_fifo_clear_deq_ntf (s->tx_fifo);
821
Florin Coras72b04282019-01-14 17:23:11 -0800822 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
823 if (PREDICT_FALSE (!app_wrk))
Florin Coras208daa12018-07-02 01:30:51 -0700824 return -1;
825
Florin Coras72b04282019-01-14 17:23:11 -0800826 if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s,
Florin Corasf6c43132019-03-01 12:41:21 -0800827 SESSION_IO_EVT_TX)))
Florin Coras1bcad5c2019-01-09 20:04:38 -0800828 return -1;
829
Florin Corasc547e912020-12-08 17:50:45 -0800830 if (PREDICT_FALSE (s->tx_fifo->shr->n_subscribers))
Florin Coras72b04282019-01-14 17:23:11 -0800831 return session_notify_subscribers (app_wrk->app_index, s,
Florin Corasf6c43132019-03-01 12:41:21 -0800832 s->tx_fifo, SESSION_IO_EVT_TX);
Florin Coras72b04282019-01-14 17:23:11 -0800833
Florin Coras1bcad5c2019-01-09 20:04:38 -0800834 return 0;
Florin Coras0d60a0f2018-06-29 02:02:08 -0700835}
836
Dave Barach68b0fb02017-02-28 15:15:56 -0500837/**
838 * Flushes queue of sessions that are to be notified of new data
839 * enqueued events.
840 *
841 * @param thread_index Thread index for which the flush is to be performed.
842 * @return 0 on success or a positive number indicating the number of
843 * failures due to API queue being full.
844 */
845int
Florin Coras31c99552019-03-01 13:00:58 -0800846session_main_flush_enqueue_events (u8 transport_proto, u32 thread_index)
Dave Barach68b0fb02017-02-28 15:15:56 -0500847{
Florin Coras31c99552019-03-01 13:00:58 -0800848 session_worker_t *wrk = session_main_get_worker (thread_index);
Florin Coras288eaab2019-02-03 15:26:14 -0800849 session_t *s;
Florin Coras21795132018-09-09 09:40:51 -0700850 int i, errors = 0;
Florin Coras3c2fed52018-07-04 04:15:05 -0700851 u32 *indices;
Dave Barach68b0fb02017-02-28 15:15:56 -0500852
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700853 indices = wrk->session_to_enqueue[transport_proto];
Dave Barach68b0fb02017-02-28 15:15:56 -0500854
Florin Coras3cbc04b2017-10-02 00:18:51 -0700855 for (i = 0; i < vec_len (indices); i++)
Dave Barach68b0fb02017-02-28 15:15:56 -0500856 {
Florin Coras3cbc04b2017-10-02 00:18:51 -0700857 s = session_get_if_valid (indices[i], thread_index);
Florin Coras3c2fed52018-07-04 04:15:05 -0700858 if (PREDICT_FALSE (!s))
859 {
860 errors++;
861 continue;
862 }
Florin Coras653e43f2019-03-04 10:56:23 -0800863
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000864 session_fifo_tuning (s, s->rx_fifo, SESSION_FT_ACTION_ENQUEUED,
865 0 /* TODO/not needed */ );
866
Florin Coras653e43f2019-03-04 10:56:23 -0800867 if (PREDICT_FALSE (session_enqueue_notify_inline (s)))
Florin Coras3cbc04b2017-10-02 00:18:51 -0700868 errors++;
Dave Barach68b0fb02017-02-28 15:15:56 -0500869 }
870
Florin Coras3cbc04b2017-10-02 00:18:51 -0700871 vec_reset_length (indices);
Florin Coras5a7ca7b2018-10-30 12:01:48 -0700872 wrk->session_to_enqueue[transport_proto] = indices;
Dave Barach68b0fb02017-02-28 15:15:56 -0500873
874 return errors;
875}
876
Florin Coras7fb0fe12018-04-09 09:24:52 -0700877int
Florin Coras31c99552019-03-01 13:00:58 -0800878session_main_flush_all_enqueue_events (u8 transport_proto)
Florin Coras7fb0fe12018-04-09 09:24:52 -0700879{
880 vlib_thread_main_t *vtm = vlib_get_thread_main ();
881 int i, errors = 0;
882 for (i = 0; i < 1 + vtm->n_threads; i++)
Florin Coras31c99552019-03-01 13:00:58 -0800883 errors += session_main_flush_enqueue_events (transport_proto, i);
Florin Coras7fb0fe12018-04-09 09:24:52 -0700884 return errors;
885}
886
Florin Coras4fde4ae2020-04-13 16:48:04 +0000887int
888session_stream_connect_notify (transport_connection_t * tc,
889 session_error_t err)
Dave Barach68b0fb02017-02-28 15:15:56 -0500890{
Florin Coras371ca502018-02-21 12:07:41 -0800891 u32 opaque = 0, new_ti, new_si;
Florin Coras15531972018-08-12 23:50:53 -0700892 app_worker_t *app_wrk;
Florin Corasea727642021-05-07 19:39:43 -0700893 session_t *s = 0, *ho;
Dave Barach68b0fb02017-02-28 15:15:56 -0500894
Florin Coras3cbc04b2017-10-02 00:18:51 -0700895 /*
Florin Corasea727642021-05-07 19:39:43 -0700896 * Cleanup half-open table
Florin Coras3cbc04b2017-10-02 00:18:51 -0700897 */
Florin Corascea194d2017-10-02 00:18:51 -0700898 session_lookup_del_half_open (tc);
Florin Coras4eeeaaf2017-09-05 14:03:37 -0400899
Florin Corasea727642021-05-07 19:39:43 -0700900 ho = ho_session_get (tc->s_index);
901 opaque = ho->opaque;
902 app_wrk = app_worker_get_if_valid (ho->app_wrk_index);
Florin Coras15531972018-08-12 23:50:53 -0700903 if (!app_wrk)
Florin Corasc87c91d2017-08-16 19:55:49 -0700904 return -1;
Florin Corasa27a46e2019-02-18 13:02:28 -0800905
Florin Coras00e01d32019-10-21 16:07:46 -0700906 if (err)
907 return app_worker_connect_notify (app_wrk, s, err, opaque);
Florin Corasa27a46e2019-02-18 13:02:28 -0800908
909 s = session_alloc_for_connection (tc);
910 s->session_state = SESSION_STATE_CONNECTING;
911 s->app_wrk_index = app_wrk->wrk_index;
912 new_si = s->session_index;
913 new_ti = s->thread_index;
914
Florin Coras00e01d32019-10-21 16:07:46 -0700915 if ((err = app_worker_init_connected (app_wrk, s)))
Dave Barach68b0fb02017-02-28 15:15:56 -0500916 {
Florin Corasa27a46e2019-02-18 13:02:28 -0800917 session_free (s);
Florin Coras00e01d32019-10-21 16:07:46 -0700918 app_worker_connect_notify (app_wrk, 0, err, opaque);
Florin Corasa27a46e2019-02-18 13:02:28 -0800919 return -1;
Dave Barach68b0fb02017-02-28 15:15:56 -0500920 }
921
Nathan Skrzypczaka26349d2019-06-26 13:53:08 +0200922 s = session_get (new_si, new_ti);
Florin Coras4fde4ae2020-04-13 16:48:04 +0000923 s->session_state = SESSION_STATE_READY;
Nathan Skrzypczaka26349d2019-06-26 13:53:08 +0200924 session_lookup_add_connection (tc, session_handle (s));
925
Florin Coras00e01d32019-10-21 16:07:46 -0700926 if (app_worker_connect_notify (app_wrk, s, SESSION_E_NONE, opaque))
Florin Coras6534b7a2017-07-18 05:38:03 -0400927 {
Florin Corasc7fd24e2020-07-24 10:09:07 -0700928 session_lookup_del_connection (tc);
929 /* Avoid notifying app about rejected session cleanup */
Florin Corasa27a46e2019-02-18 13:02:28 -0800930 s = session_get (new_si, new_ti);
Florin Corasc7fd24e2020-07-24 10:09:07 -0700931 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
932 session_free (s);
Florin Corasa27a46e2019-02-18 13:02:28 -0800933 return -1;
Florin Coras6534b7a2017-07-18 05:38:03 -0400934 }
Dave Barach68b0fb02017-02-28 15:15:56 -0500935
Florin Corasa27a46e2019-02-18 13:02:28 -0800936 return 0;
Dave Barach68b0fb02017-02-28 15:15:56 -0500937}
938
Florin Coras02000442021-11-16 12:45:43 -0800939typedef union session_switch_pool_reply_args_
940{
941 struct
942 {
943 u32 session_index;
944 u16 thread_index;
945 u8 is_closed;
946 };
947 u64 as_u64;
948} session_switch_pool_reply_args_t;
949
950STATIC_ASSERT (sizeof (session_switch_pool_reply_args_t) <= sizeof (uword),
951 "switch pool reply args size");
952
Florin Coras6d7552c2020-04-09 01:49:45 +0000953static void
954session_switch_pool_reply (void *arg)
955{
Florin Coras02000442021-11-16 12:45:43 -0800956 session_switch_pool_reply_args_t rargs;
Florin Coras6d7552c2020-04-09 01:49:45 +0000957 session_t *s;
958
Florin Coras02000442021-11-16 12:45:43 -0800959 rargs.as_u64 = pointer_to_uword (arg);
960 s = session_get_if_valid (rargs.session_index, rargs.thread_index);
Florin Coras6d7552c2020-04-09 01:49:45 +0000961 if (!s)
962 return;
963
Florin Coras02000442021-11-16 12:45:43 -0800964 /* Session closed during migration. Clean everything up */
965 if (rargs.is_closed)
966 {
967 transport_cleanup (session_get_transport_proto (s), s->connection_index,
968 s->thread_index);
969 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
970 session_free (s);
971 return;
972 }
973
Florin Coras6d7552c2020-04-09 01:49:45 +0000974 /* Notify app that it has data on the new session */
975 session_enqueue_notify (s);
976}
977
Florin Coras3cbc04b2017-10-02 00:18:51 -0700978typedef struct _session_switch_pool_args
979{
980 u32 session_index;
981 u32 thread_index;
982 u32 new_thread_index;
983 u32 new_session_index;
984} session_switch_pool_args_t;
985
Florin Coras49568af2019-07-31 16:46:24 -0700986/**
987 * Notify old thread of the session pool switch
988 */
Florin Coras3cbc04b2017-10-02 00:18:51 -0700989static void
990session_switch_pool (void *cb_args)
991{
992 session_switch_pool_args_t *args = (session_switch_pool_args_t *) cb_args;
Florin Coras02000442021-11-16 12:45:43 -0800993 session_switch_pool_reply_args_t rargs;
Florin Coras6d7552c2020-04-09 01:49:45 +0000994 session_handle_t new_sh;
995 segment_manager_t *sm;
Florin Coras49568af2019-07-31 16:46:24 -0700996 app_worker_t *app_wrk;
Florin Coras288eaab2019-02-03 15:26:14 -0800997 session_t *s;
Florin Coras49568af2019-07-31 16:46:24 -0700998
Florin Coras3cbc04b2017-10-02 00:18:51 -0700999 ASSERT (args->thread_index == vlib_get_thread_index ());
1000 s = session_get (args->session_index, args->thread_index);
Florin Coras6d7552c2020-04-09 01:49:45 +00001001
Florin Corasfc8d0c52021-11-17 11:41:10 -08001002 /* Check if session closed during migration */
1003 rargs.is_closed = s->session_state >= SESSION_STATE_TRANSPORT_CLOSING;
1004
Florin Coras1ee78302019-02-05 15:51:15 -08001005 transport_cleanup (session_get_transport_proto (s), s->connection_index,
1006 s->thread_index);
Florin Coras49568af2019-07-31 16:46:24 -07001007
1008 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
1009 if (app_wrk)
1010 {
Florin Coras6d7552c2020-04-09 01:49:45 +00001011 /* Cleanup fifo segment slice state for fifos */
1012 sm = app_worker_get_connect_segment_manager (app_wrk);
Florin Coras0bc78d82021-01-09 14:34:01 -08001013 segment_manager_detach_fifo (sm, &s->rx_fifo);
1014 segment_manager_detach_fifo (sm, &s->tx_fifo);
Aloys Augustinb3392332019-08-06 16:09:01 +02001015
Florin Coras6d7552c2020-04-09 01:49:45 +00001016 /* Notify app, using old session, about the migration event */
Florin Coras02000442021-11-16 12:45:43 -08001017 if (!rargs.is_closed)
1018 {
1019 new_sh = session_make_handle (args->new_session_index,
1020 args->new_thread_index);
1021 app_worker_migrate_notify (app_wrk, s, new_sh);
1022 }
Florin Coras49568af2019-07-31 16:46:24 -07001023 }
1024
Florin Coras6d7552c2020-04-09 01:49:45 +00001025 /* Trigger app read and fifo updates on the new thread */
Florin Coras02000442021-11-16 12:45:43 -08001026 rargs.session_index = args->new_session_index;
1027 rargs.thread_index = args->new_thread_index;
Florin Coras6d7552c2020-04-09 01:49:45 +00001028 session_send_rpc_evt_to_thread (args->new_thread_index,
Florin Coras02000442021-11-16 12:45:43 -08001029 session_switch_pool_reply,
1030 uword_to_pointer (rargs.as_u64, void *));
Florin Coras6d7552c2020-04-09 01:49:45 +00001031
Florin Coras3cbc04b2017-10-02 00:18:51 -07001032 session_free (s);
1033 clib_mem_free (cb_args);
1034}
1035
1036/**
1037 * Move dgram session to the right thread
1038 */
1039int
1040session_dgram_connect_notify (transport_connection_t * tc,
Florin Coras288eaab2019-02-03 15:26:14 -08001041 u32 old_thread_index, session_t ** new_session)
Florin Coras3cbc04b2017-10-02 00:18:51 -07001042{
Florin Coras288eaab2019-02-03 15:26:14 -08001043 session_t *new_s;
Florin Coras3cbc04b2017-10-02 00:18:51 -07001044 session_switch_pool_args_t *rpc_args;
Florin Coras0bc78d82021-01-09 14:34:01 -08001045 segment_manager_t *sm;
1046 app_worker_t *app_wrk;
Florin Coras3cbc04b2017-10-02 00:18:51 -07001047
1048 /*
1049 * Clone half-open session to the right thread.
1050 */
1051 new_s = session_clone_safe (tc->s_index, old_thread_index);
1052 new_s->connection_index = tc->c_index;
Florin Coras3cbc04b2017-10-02 00:18:51 -07001053 new_s->session_state = SESSION_STATE_READY;
Nathan Skrzypczakcaa7acf2019-10-02 10:02:05 +02001054 new_s->flags |= SESSION_F_IS_MIGRATING;
Florin Coras6d7552c2020-04-09 01:49:45 +00001055
Florin Coras0bc78d82021-01-09 14:34:01 -08001056 if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
1057 session_lookup_add_connection (tc, session_handle (new_s));
1058
1059 app_wrk = app_worker_get_if_valid (new_s->app_wrk_index);
1060 if (app_wrk)
1061 {
1062 /* New set of fifos attached to the same shared memory */
1063 sm = app_worker_get_connect_segment_manager (app_wrk);
1064 segment_manager_attach_fifo (sm, &new_s->rx_fifo, new_s);
1065 segment_manager_attach_fifo (sm, &new_s->tx_fifo, new_s);
1066 }
Florin Coras3cbc04b2017-10-02 00:18:51 -07001067
1068 /*
1069 * Ask thread owning the old session to clean it up and make us the tx
1070 * fifo owner
1071 */
1072 rpc_args = clib_mem_alloc (sizeof (*rpc_args));
1073 rpc_args->new_session_index = new_s->session_index;
1074 rpc_args->new_thread_index = new_s->thread_index;
1075 rpc_args->session_index = tc->s_index;
1076 rpc_args->thread_index = old_thread_index;
1077 session_send_rpc_evt_to_thread (rpc_args->thread_index, session_switch_pool,
1078 rpc_args);
1079
1080 tc->s_index = new_s->session_index;
1081 new_s->connection_index = tc->c_index;
1082 *new_session = new_s;
1083 return 0;
1084}
1085
Dave Barach68b0fb02017-02-28 15:15:56 -05001086/**
1087 * Notification from transport that connection is being closed.
1088 *
1089 * A disconnect is sent to application but state is not removed. Once
1090 * disconnect is acknowledged by application, session disconnect is called.
1091 * Ultimately this leads to close being called on transport (passive close).
1092 */
1093void
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001094session_transport_closing_notify (transport_connection_t * tc)
Dave Barach68b0fb02017-02-28 15:15:56 -05001095{
Florin Coras15531972018-08-12 23:50:53 -07001096 app_worker_t *app_wrk;
Florin Coras288eaab2019-02-03 15:26:14 -08001097 session_t *s;
Dave Barach68b0fb02017-02-28 15:15:56 -05001098
Florin Corascea194d2017-10-02 00:18:51 -07001099 s = session_get (tc->s_index, tc->thread_index);
Florin Coras400ded32018-10-03 01:00:57 -07001100 if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING)
1101 return;
Florin Corasdfd27bc2021-11-27 10:45:55 -08001102
1103 /* Wait for reply from app before sending notification as the
1104 * accept might be rejected */
1105 if (s->session_state == SESSION_STATE_ACCEPTING)
1106 {
1107 s->session_state = SESSION_STATE_TRANSPORT_CLOSING;
1108 return;
1109 }
1110
Florin Coras568ebc72018-09-18 16:12:50 -07001111 s->session_state = SESSION_STATE_TRANSPORT_CLOSING;
Florin Corasbf7ce2c2019-03-06 14:44:42 -08001112 app_wrk = app_worker_get (s->app_wrk_index);
1113 app_worker_close_notify (app_wrk, s);
Dave Barach68b0fb02017-02-28 15:15:56 -05001114}
1115
1116/**
Dave Barach68b0fb02017-02-28 15:15:56 -05001117 * Notification from transport that connection is being deleted
1118 *
Florin Coras4eeeaaf2017-09-05 14:03:37 -04001119 * This removes the session if it is still valid. It should be called only on
1120 * previously fully established sessions. For instance failed connects should
1121 * call stream_session_connect_notify and indicate that the connect has
1122 * failed.
Dave Barach68b0fb02017-02-28 15:15:56 -05001123 */
1124void
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001125session_transport_delete_notify (transport_connection_t * tc)
Dave Barach68b0fb02017-02-28 15:15:56 -05001126{
Florin Coras288eaab2019-02-03 15:26:14 -08001127 session_t *s;
Dave Barach68b0fb02017-02-28 15:15:56 -05001128
Florin Corase04c2992017-03-01 08:17:34 -08001129 /* App might've been removed already */
Florin Coras568ebc72018-09-18 16:12:50 -07001130 if (!(s = session_get_if_valid (tc->s_index, tc->thread_index)))
Florin Corasc87c91d2017-08-16 19:55:49 -07001131 return;
Florin Coras568ebc72018-09-18 16:12:50 -07001132
Florin Coras568ebc72018-09-18 16:12:50 -07001133 switch (s->session_state)
1134 {
Florin Coras222e1f412019-02-16 20:47:32 -08001135 case SESSION_STATE_CREATED:
1136 /* Session was created but accept notification was not yet sent to the
1137 * app. Cleanup everything. */
1138 session_lookup_del_session (s);
Zeyu Zhangcbbc4a22019-10-12 14:21:59 +08001139 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
1140 session_free (s);
Florin Coras222e1f412019-02-16 20:47:32 -08001141 break;
Florin Corasb0f662f2018-12-27 14:51:46 -08001142 case SESSION_STATE_ACCEPTING:
Florin Coras568ebc72018-09-18 16:12:50 -07001143 case SESSION_STATE_TRANSPORT_CLOSING:
Florin Coras692b9492019-07-12 15:01:53 -07001144 case SESSION_STATE_CLOSING:
Florin Coras5f066322019-07-22 19:03:03 -07001145 case SESSION_STATE_TRANSPORT_CLOSED:
Florin Coras568ebc72018-09-18 16:12:50 -07001146 /* If transport finishes or times out before we get a reply
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001147 * from the app, mark transport as closed and wait for reply
1148 * before removing the session. Cleanup session table in advance
Florin Corasa9d5bea2018-12-17 08:24:19 -08001149 * because transport will soon be closed and closed sessions
1150 * are assumed to have been removed from the lookup table */
1151 session_lookup_del_session (s);
Florin Coras5f066322019-07-22 19:03:03 -07001152 s->session_state = SESSION_STATE_TRANSPORT_DELETED;
Florin Coras70f26d52019-07-08 11:47:18 -07001153 session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT);
1154 svm_fifo_dequeue_drop_all (s->tx_fifo);
Florin Coras568ebc72018-09-18 16:12:50 -07001155 break;
Florin Coras692b9492019-07-12 15:01:53 -07001156 case SESSION_STATE_APP_CLOSED:
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001157 /* Cleanup lookup table as transport needs to still be valid.
1158 * Program transport close to ensure that all session events
1159 * have been cleaned up. Once transport close is called, the
1160 * session is just removed because both transport and app have
1161 * confirmed the close*/
Florin Coras568ebc72018-09-18 16:12:50 -07001162 session_lookup_del_session (s);
Florin Coras3b5e2222019-10-25 16:23:39 -07001163 s->session_state = SESSION_STATE_TRANSPORT_DELETED;
Florin Coras70f26d52019-07-08 11:47:18 -07001164 session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT);
1165 svm_fifo_dequeue_drop_all (s->tx_fifo);
Florin Corasdfb3b872019-08-16 17:48:44 -07001166 session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE);
Florin Coras568ebc72018-09-18 16:12:50 -07001167 break;
Florin Coras5f066322019-07-22 19:03:03 -07001168 case SESSION_STATE_TRANSPORT_DELETED:
Florin Corasb0f662f2018-12-27 14:51:46 -08001169 break;
Florin Coras568ebc72018-09-18 16:12:50 -07001170 case SESSION_STATE_CLOSED:
Florin Coras70f26d52019-07-08 11:47:18 -07001171 session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT);
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001172 session_delete (s);
Florin Coras568ebc72018-09-18 16:12:50 -07001173 break;
Florin Corasc01d5782018-10-17 14:53:11 -07001174 default:
Florin Corasb0f662f2018-12-27 14:51:46 -08001175 clib_warning ("session state %u", s->session_state);
Florin Coras70f26d52019-07-08 11:47:18 -07001176 session_cleanup_notify (s, SESSION_CLEANUP_TRANSPORT);
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001177 session_delete (s);
Florin Corasc01d5782018-10-17 14:53:11 -07001178 break;
Florin Coras568ebc72018-09-18 16:12:50 -07001179 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001180}
1181
1182/**
Florin Coras692b9492019-07-12 15:01:53 -07001183 * Notification from transport that it is closed
Florin Coras54ddf432018-12-21 13:54:09 -08001184 *
Florin Coras692b9492019-07-12 15:01:53 -07001185 * Should be called by transport, prior to calling delete notify, once it
1186 * knows that no more data will be exchanged. This could serve as an
1187 * early acknowledgment of an active close especially if transport delete
1188 * can be delayed a long time, e.g., tcp time-wait.
Florin Coras54ddf432018-12-21 13:54:09 -08001189 */
1190void
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001191session_transport_closed_notify (transport_connection_t * tc)
Florin Coras54ddf432018-12-21 13:54:09 -08001192{
Florin Coras692b9492019-07-12 15:01:53 -07001193 app_worker_t *app_wrk;
Florin Coras288eaab2019-02-03 15:26:14 -08001194 session_t *s;
Florin Coras54ddf432018-12-21 13:54:09 -08001195
1196 if (!(s = session_get_if_valid (tc->s_index, tc->thread_index)))
1197 return;
Florin Corasb0f662f2018-12-27 14:51:46 -08001198
Florin Coras06a2eec2019-05-23 22:28:16 -07001199 /* Transport thinks that app requested close but it actually didn't.
liuyacan534468e2021-05-09 03:50:40 +00001200 * Can happen for tcp:
1201 * 1)if fin and rst are received in close succession.
1202 * 2)if app shutdown the connection. */
Florin Coras06a2eec2019-05-23 22:28:16 -07001203 if (s->session_state == SESSION_STATE_READY)
1204 {
1205 session_transport_closing_notify (tc);
1206 svm_fifo_dequeue_drop_all (s->tx_fifo);
Florin Coras692b9492019-07-12 15:01:53 -07001207 s->session_state = SESSION_STATE_TRANSPORT_CLOSED;
Florin Coras06a2eec2019-05-23 22:28:16 -07001208 }
Florin Corasb0f662f2018-12-27 14:51:46 -08001209 /* If app close has not been received or has not yet resulted in
1210 * a transport close, only mark the session transport as closed */
Florin Coras06a2eec2019-05-23 22:28:16 -07001211 else if (s->session_state <= SESSION_STATE_CLOSING)
Florin Corasb0f662f2018-12-27 14:51:46 -08001212 {
Florin Corasb0f662f2018-12-27 14:51:46 -08001213 s->session_state = SESSION_STATE_TRANSPORT_CLOSED;
1214 }
Florin Coras5f066322019-07-22 19:03:03 -07001215 /* If app also closed, switch to closed */
1216 else if (s->session_state == SESSION_STATE_APP_CLOSED)
Florin Corasb0f662f2018-12-27 14:51:46 -08001217 s->session_state = SESSION_STATE_CLOSED;
Florin Coras692b9492019-07-12 15:01:53 -07001218
1219 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
1220 if (app_wrk)
1221 app_worker_transport_closed_notify (app_wrk, s);
Florin Coras54ddf432018-12-21 13:54:09 -08001222}
1223
1224/**
Dave Barach68b0fb02017-02-28 15:15:56 -05001225 * Notify application that connection has been reset.
1226 */
1227void
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001228session_transport_reset_notify (transport_connection_t * tc)
Dave Barach68b0fb02017-02-28 15:15:56 -05001229{
Florin Coras15531972018-08-12 23:50:53 -07001230 app_worker_t *app_wrk;
Florin Coras69b68ef2019-04-02 11:38:51 -07001231 session_t *s;
1232
Florin Corascea194d2017-10-02 00:18:51 -07001233 s = session_get (tc->s_index, tc->thread_index);
Florin Coras288eaab2019-02-03 15:26:14 -08001234 svm_fifo_dequeue_drop_all (s->tx_fifo);
Florin Coras3c7d4f92018-12-14 11:28:43 -08001235 if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING)
1236 return;
Florin Corasdfd27bc2021-11-27 10:45:55 -08001237 if (s->session_state == SESSION_STATE_ACCEPTING)
1238 {
1239 s->session_state = SESSION_STATE_TRANSPORT_CLOSING;
1240 return;
1241 }
Florin Coras3c7d4f92018-12-14 11:28:43 -08001242 s->session_state = SESSION_STATE_TRANSPORT_CLOSING;
Florin Coras15531972018-08-12 23:50:53 -07001243 app_wrk = app_worker_get (s->app_wrk_index);
Florin Coras69b68ef2019-04-02 11:38:51 -07001244 app_worker_reset_notify (app_wrk, s);
Dave Barach68b0fb02017-02-28 15:15:56 -05001245}
1246
Florin Corasa27a46e2019-02-18 13:02:28 -08001247int
1248session_stream_accept_notify (transport_connection_t * tc)
1249{
1250 app_worker_t *app_wrk;
1251 session_t *s;
1252
1253 s = session_get (tc->s_index, tc->thread_index);
1254 app_wrk = app_worker_get_if_valid (s->app_wrk_index);
1255 if (!app_wrk)
1256 return -1;
Florin Coras600d7a82021-04-29 11:55:23 -07001257 if (s->session_state != SESSION_STATE_CREATED)
1258 return 0;
Florin Corasa27a46e2019-02-18 13:02:28 -08001259 s->session_state = SESSION_STATE_ACCEPTING;
Florin Coras4dc10a42020-02-11 05:31:49 +00001260 if (app_worker_accept_notify (app_wrk, s))
1261 {
1262 /* On transport delete, no notifications should be sent. Unless, the
1263 * accept is retried and successful. */
1264 s->session_state = SESSION_STATE_CREATED;
1265 return -1;
1266 }
1267 return 0;
Florin Corasa27a46e2019-02-18 13:02:28 -08001268}
1269
Dave Barach68b0fb02017-02-28 15:15:56 -05001270/**
1271 * Accept a stream session. Optionally ping the server by callback.
1272 */
1273int
Florin Corasc9940fc2019-02-05 20:55:11 -08001274session_stream_accept (transport_connection_t * tc, u32 listener_index,
Nathan Skrzypczak2f0f96b2019-06-13 10:14:28 +02001275 u32 thread_index, u8 notify)
Dave Barach68b0fb02017-02-28 15:15:56 -05001276{
Florin Corasa27a46e2019-02-18 13:02:28 -08001277 session_t *s;
Dave Barach68b0fb02017-02-28 15:15:56 -05001278 int rv;
1279
Florin Corasa27a46e2019-02-18 13:02:28 -08001280 s = session_alloc_for_connection (tc);
Nathan Skrzypczak2f0f96b2019-06-13 10:14:28 +02001281 s->listener_handle = ((u64) thread_index << 32) | (u64) listener_index;
Florin Coras222e1f412019-02-16 20:47:32 -08001282 s->session_state = SESSION_STATE_CREATED;
Dave Barach68b0fb02017-02-28 15:15:56 -05001283
Florin Corasa27a46e2019-02-18 13:02:28 -08001284 if ((rv = app_worker_init_accepted (s)))
Florin Coras12813d52020-04-09 20:59:20 +00001285 {
1286 session_free (s);
1287 return rv;
1288 }
Florin Corasa27a46e2019-02-18 13:02:28 -08001289
1290 session_lookup_add_connection (tc, session_handle (s));
1291
Dave Barach68b0fb02017-02-28 15:15:56 -05001292 /* Shoulder-tap the server */
1293 if (notify)
1294 {
Florin Corasa27a46e2019-02-18 13:02:28 -08001295 app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
Florin Coras12813d52020-04-09 20:59:20 +00001296 if ((rv = app_worker_accept_notify (app_wrk, s)))
1297 {
1298 session_lookup_del_session (s);
1299 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
1300 session_free (s);
1301 return rv;
1302 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001303 }
1304
1305 return 0;
1306}
1307
Florin Coras371ca502018-02-21 12:07:41 -08001308int
Florin Corase759bb52020-04-08 01:55:39 +00001309session_dgram_accept (transport_connection_t * tc, u32 listener_index,
1310 u32 thread_index)
1311{
1312 app_worker_t *app_wrk;
1313 session_t *s;
1314 int rv;
1315
1316 s = session_alloc_for_connection (tc);
1317 s->listener_handle = ((u64) thread_index << 32) | (u64) listener_index;
1318
1319 if ((rv = app_worker_init_accepted (s)))
1320 {
1321 session_free (s);
1322 return rv;
1323 }
1324
Florin Coras473556d2020-11-23 15:59:36 -08001325 session_lookup_add_connection (tc, session_handle (s));
1326
Florin Corase759bb52020-04-08 01:55:39 +00001327 app_wrk = app_worker_get (s->app_wrk_index);
1328 if ((rv = app_worker_accept_notify (app_wrk, s)))
1329 {
Florin Coras473556d2020-11-23 15:59:36 -08001330 session_lookup_del_session (s);
Florin Coras12813d52020-04-09 20:59:20 +00001331 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
1332 session_free (s);
Florin Corase759bb52020-04-08 01:55:39 +00001333 return rv;
1334 }
1335
Florin Corase759bb52020-04-08 01:55:39 +00001336 return 0;
1337}
1338
1339int
Florin Coras89a9f612021-05-11 11:55:07 -07001340session_open_cl (session_endpoint_cfg_t *rmt, session_handle_t *rsh)
Florin Coras371ca502018-02-21 12:07:41 -08001341{
1342 transport_connection_t *tc;
Florin Coras5665ced2018-10-25 18:03:45 -07001343 transport_endpoint_cfg_t *tep;
Florin Coras15531972018-08-12 23:50:53 -07001344 app_worker_t *app_wrk;
Aloys Augustin20ab31e2019-03-25 11:29:17 +01001345 session_handle_t sh;
Florin Coras288eaab2019-02-03 15:26:14 -08001346 session_t *s;
Florin Coras371ca502018-02-21 12:07:41 -08001347 int rv;
1348
Florin Coras5665ced2018-10-25 18:03:45 -07001349 tep = session_endpoint_to_transport_cfg (rmt);
Florin Coras1ee78302019-02-05 15:51:15 -08001350 rv = transport_connect (rmt->transport_proto, tep);
Florin Coras371ca502018-02-21 12:07:41 -08001351 if (rv < 0)
1352 {
1353 SESSION_DBG ("Transport failed to open connection.");
Florin Coras57660d92020-04-04 22:45:34 +00001354 return rv;
Florin Coras371ca502018-02-21 12:07:41 -08001355 }
1356
Florin Coras1ee78302019-02-05 15:51:15 -08001357 tc = transport_get_half_open (rmt->transport_proto, (u32) rv);
Florin Coras371ca502018-02-21 12:07:41 -08001358
Florin Corasa27a46e2019-02-18 13:02:28 -08001359 /* For dgram type of service, allocate session and fifos now */
Florin Coras89a9f612021-05-11 11:55:07 -07001360 app_wrk = app_worker_get (rmt->app_wrk_index);
Florin Corasa27a46e2019-02-18 13:02:28 -08001361 s = session_alloc_for_connection (tc);
Florin Coras15531972018-08-12 23:50:53 -07001362 s->app_wrk_index = app_wrk->wrk_index;
Florin Coras7fb0fe12018-04-09 09:24:52 -07001363 s->session_state = SESSION_STATE_OPENED;
Florin Corasa27a46e2019-02-18 13:02:28 -08001364 if (app_worker_init_connected (app_wrk, s))
1365 {
1366 session_free (s);
1367 return -1;
1368 }
Florin Coras371ca502018-02-21 12:07:41 -08001369
Aloys Augustin20ab31e2019-03-25 11:29:17 +01001370 sh = session_handle (s);
Florin Coras89a9f612021-05-11 11:55:07 -07001371 *rsh = sh;
1372
Aloys Augustin20ab31e2019-03-25 11:29:17 +01001373 session_lookup_add_connection (tc, sh);
Florin Coras89a9f612021-05-11 11:55:07 -07001374 return app_worker_connect_notify (app_wrk, s, SESSION_E_NONE, rmt->opaque);
Florin Coras371ca502018-02-21 12:07:41 -08001375}
1376
1377int
Florin Coras89a9f612021-05-11 11:55:07 -07001378session_open_vc (session_endpoint_cfg_t *rmt, session_handle_t *rsh)
Florin Coras371ca502018-02-21 12:07:41 -08001379{
1380 transport_connection_t *tc;
Florin Coras5665ced2018-10-25 18:03:45 -07001381 transport_endpoint_cfg_t *tep;
Florin Corasea727642021-05-07 19:39:43 -07001382 app_worker_t *app_wrk;
Florin Coras89a9f612021-05-11 11:55:07 -07001383 session_t *ho;
Florin Coras371ca502018-02-21 12:07:41 -08001384 int rv;
1385
Florin Coras5665ced2018-10-25 18:03:45 -07001386 tep = session_endpoint_to_transport_cfg (rmt);
Florin Coras1ee78302019-02-05 15:51:15 -08001387 rv = transport_connect (rmt->transport_proto, tep);
Florin Coras371ca502018-02-21 12:07:41 -08001388 if (rv < 0)
1389 {
1390 SESSION_DBG ("Transport failed to open connection.");
Florin Coras57660d92020-04-04 22:45:34 +00001391 return rv;
Florin Coras371ca502018-02-21 12:07:41 -08001392 }
1393
Florin Coras1ee78302019-02-05 15:51:15 -08001394 tc = transport_get_half_open (rmt->transport_proto, (u32) rv);
Florin Coras371ca502018-02-21 12:07:41 -08001395
Florin Coras89a9f612021-05-11 11:55:07 -07001396 app_wrk = app_worker_get (rmt->app_wrk_index);
Florin Coras371ca502018-02-21 12:07:41 -08001397
Florin Corasea727642021-05-07 19:39:43 -07001398 /* If transport offers a vc service, only allocate established
1399 * session once the connection has been established.
1400 * In the meantime allocate half-open session for tracking purposes
1401 * associate half-open connection to it and add session to app-worker
1402 * half-open table. These are needed to allocate the established
1403 * session on transport notification, and to cleanup the half-open
1404 * session if the app detaches before connection establishment.
Florin Coras371ca502018-02-21 12:07:41 -08001405 */
Florin Coras89a9f612021-05-11 11:55:07 -07001406 ho = session_alloc_for_half_open (tc);
1407 ho->app_wrk_index = app_wrk->wrk_index;
1408 ho->ho_index = app_worker_add_half_open (app_wrk, session_handle (ho));
1409 ho->opaque = rmt->opaque;
1410 *rsh = session_handle (ho);
Florin Corasd50ff7f2020-04-16 04:30:22 +00001411
Florin Coras2c876f92021-05-10 21:12:27 -07001412 if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
1413 session_lookup_add_half_open (tc, tc->c_index);
Florin Coras4fde4ae2020-04-13 16:48:04 +00001414
Florin Coras371ca502018-02-21 12:07:41 -08001415 return 0;
1416}
1417
1418int
Florin Coras89a9f612021-05-11 11:55:07 -07001419session_open_app (session_endpoint_cfg_t *rmt, session_handle_t *rsh)
Florin Coras371ca502018-02-21 12:07:41 -08001420{
Florin Coras89a9f612021-05-11 11:55:07 -07001421 transport_endpoint_cfg_t *tep_cfg = session_endpoint_to_transport_cfg (rmt);
Florin Coras5665ced2018-10-25 18:03:45 -07001422
Florin Coras89a9f612021-05-11 11:55:07 -07001423 /* Not supported for now */
1424 *rsh = SESSION_INVALID_HANDLE;
Florin Coras1ee78302019-02-05 15:51:15 -08001425 return transport_connect (rmt->transport_proto, tep_cfg);
Florin Coras371ca502018-02-21 12:07:41 -08001426}
1427
Florin Coras89a9f612021-05-11 11:55:07 -07001428typedef int (*session_open_service_fn) (session_endpoint_cfg_t *,
1429 session_handle_t *);
Florin Coras371ca502018-02-21 12:07:41 -08001430
1431/* *INDENT-OFF* */
1432static session_open_service_fn session_open_srv_fns[TRANSPORT_N_SERVICES] = {
1433 session_open_vc,
1434 session_open_cl,
1435 session_open_app,
1436};
1437/* *INDENT-ON* */
1438
Florin Coras6cf30ad2017-04-04 23:08:23 -07001439/**
1440 * Ask transport to open connection to remote transport endpoint.
1441 *
1442 * Stores handle for matching request with reply since the call can be
1443 * asynchronous. For instance, for TCP the 3-way handshake must complete
1444 * before reply comes. Session is only created once connection is established.
1445 *
1446 * @param app_index Index of the application requesting the connect
1447 * @param st Session type requested.
1448 * @param tep Remote transport endpoint
Florin Coras3cbc04b2017-10-02 00:18:51 -07001449 * @param opaque Opaque data (typically, api_context) the application expects
1450 * on open completion.
Florin Coras6cf30ad2017-04-04 23:08:23 -07001451 */
Florin Corase04c2992017-03-01 08:17:34 -08001452int
Florin Coras89a9f612021-05-11 11:55:07 -07001453session_open (session_endpoint_cfg_t *rmt, session_handle_t *rsh)
Dave Barach68b0fb02017-02-28 15:15:56 -05001454{
Florin Coras1ee78302019-02-05 15:51:15 -08001455 transport_service_type_t tst;
1456 tst = transport_protocol_service_type (rmt->transport_proto);
Florin Coras89a9f612021-05-11 11:55:07 -07001457 return session_open_srv_fns[tst](rmt, rsh);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001458}
1459
Florin Coras7fb0fe12018-04-09 09:24:52 -07001460/**
Florin Corasab2f6db2018-08-31 14:31:41 -07001461 * Ask transport to listen on session endpoint.
Florin Coras7fb0fe12018-04-09 09:24:52 -07001462 *
1463 * @param s Session for which listen will be called. Note that unlike
1464 * established sessions, listen sessions are not associated to a
1465 * thread.
Florin Corasab2f6db2018-08-31 14:31:41 -07001466 * @param sep Local endpoint to be listened on.
Florin Coras7fb0fe12018-04-09 09:24:52 -07001467 */
Florin Coras371ca502018-02-21 12:07:41 -08001468int
Florin Coras288eaab2019-02-03 15:26:14 -08001469session_listen (session_t * ls, session_endpoint_cfg_t * sep)
Florin Coras371ca502018-02-21 12:07:41 -08001470{
Florin Coras0bce71e2022-02-10 11:57:06 -08001471 transport_endpoint_cfg_t *tep;
Florin Corasa8c3b862020-04-07 22:31:06 +00001472 int tc_index;
1473 u32 s_index;
Florin Corasab2f6db2018-08-31 14:31:41 -07001474
1475 /* Transport bind/listen */
Florin Coras0bce71e2022-02-10 11:57:06 -08001476 tep = session_endpoint_to_transport_cfg (sep);
Florin Coras74cac882018-09-07 09:13:15 -07001477 s_index = ls->session_index;
Florin Corasd4295e62019-02-22 13:11:38 -08001478 tc_index = transport_start_listen (session_get_transport_proto (ls),
1479 s_index, tep);
Florin Corasab2f6db2018-08-31 14:31:41 -07001480
Florin Corasa8c3b862020-04-07 22:31:06 +00001481 if (tc_index < 0)
1482 return tc_index;
Florin Corasab2f6db2018-08-31 14:31:41 -07001483
Florin Corasd4295e62019-02-22 13:11:38 -08001484 /* Attach transport to session. Lookup tables are populated by the app
1485 * worker because local tables (for ct sessions) are not backed by a fib */
Florin Coras74cac882018-09-07 09:13:15 -07001486 ls = listen_session_get (s_index);
Florin Corasab2f6db2018-08-31 14:31:41 -07001487 ls->connection_index = tc_index;
1488
Florin Corasab2f6db2018-08-31 14:31:41 -07001489 return 0;
Florin Coras371ca502018-02-21 12:07:41 -08001490}
1491
Florin Coras6cf30ad2017-04-04 23:08:23 -07001492/**
1493 * Ask transport to stop listening on local transport endpoint.
1494 *
1495 * @param s Session to stop listening on. It must be in state LISTENING.
1496 */
1497int
Florin Coras288eaab2019-02-03 15:26:14 -08001498session_stop_listen (session_t * s)
Florin Coras6cf30ad2017-04-04 23:08:23 -07001499{
Florin Coras561af9b2017-12-09 10:19:43 -08001500 transport_proto_t tp = session_get_transport_proto (s);
Florin Coras6cf30ad2017-04-04 23:08:23 -07001501 transport_connection_t *tc;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001502
Florin Coras1ee78302019-02-05 15:51:15 -08001503 if (s->session_state != SESSION_STATE_LISTENING)
Florin Corasa8c3b862020-04-07 22:31:06 +00001504 return SESSION_E_NOLISTEN;
Florin Coras1ee78302019-02-05 15:51:15 -08001505
1506 tc = transport_get_listener (tp, s->connection_index);
Florin Corasa8c3b862020-04-07 22:31:06 +00001507
1508 /* If no transport, assume everything was cleaned up already */
Florin Coras6cf30ad2017-04-04 23:08:23 -07001509 if (!tc)
Florin Corasa8c3b862020-04-07 22:31:06 +00001510 return SESSION_E_NONE;
Florin Coras6cf30ad2017-04-04 23:08:23 -07001511
Nathan Skrzypczak2eed1a12019-07-04 14:26:21 +02001512 if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
1513 session_lookup_del_connection (tc);
Florin Corasa8c3b862020-04-07 22:31:06 +00001514
Florin Coras1ee78302019-02-05 15:51:15 -08001515 transport_stop_listen (tp, s->connection_index);
Florin Corase04c2992017-03-01 08:17:34 -08001516 return 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05001517}
1518
1519/**
liuyacan534468e2021-05-09 03:50:40 +00001520 * Initialize session half-closing procedure.
1521 *
1522 * Note that half-closing will not change the state of the session.
1523 */
1524void
1525session_half_close (session_t *s)
1526{
1527 if (!s)
1528 return;
1529
1530 session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_HALF_CLOSE);
1531}
1532
1533/**
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001534 * Initialize session closing procedure.
Florin Corasa5464812017-04-19 13:00:05 -07001535 *
Florin Coras2f8d8fa2018-01-26 06:36:04 -08001536 * Request is always sent to session node to ensure that all outstanding
1537 * requests are served before transport is notified.
Dave Barach68b0fb02017-02-28 15:15:56 -05001538 */
1539void
Florin Coras288eaab2019-02-03 15:26:14 -08001540session_close (session_t * s)
Dave Barach68b0fb02017-02-28 15:15:56 -05001541{
Florin Coras25579b42018-06-06 17:55:02 -07001542 if (!s)
Florin Coras2f8d8fa2018-01-26 06:36:04 -08001543 return;
Florin Coras25579b42018-06-06 17:55:02 -07001544
1545 if (s->session_state >= SESSION_STATE_CLOSING)
1546 {
Florin Coras5a2ec8f2018-12-27 11:53:11 -08001547 /* Session will only be removed once both app and transport
1548 * acknowledge the close */
Florin Coras5f066322019-07-22 19:03:03 -07001549 if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED
1550 || s->session_state == SESSION_STATE_TRANSPORT_DELETED)
Florin Corasdfb3b872019-08-16 17:48:44 -07001551 session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE);
Florin Coras25579b42018-06-06 17:55:02 -07001552 return;
1553 }
1554
Florin Coras5babf982021-11-27 10:54:29 -08001555 /* App closed so stop propagating dequeue notifications */
1556 svm_fifo_clear_deq_ntf (s->tx_fifo);
Florin Corasb2371c22018-05-31 17:14:10 -07001557 s->session_state = SESSION_STATE_CLOSING;
Florin Corasdfb3b872019-08-16 17:48:44 -07001558 session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_CLOSE);
1559}
1560
1561/**
1562 * Force a close without waiting for data to be flushed
1563 */
1564void
1565session_reset (session_t * s)
1566{
1567 if (s->session_state >= SESSION_STATE_CLOSING)
1568 return;
1569 /* Drop all outstanding tx data */
1570 svm_fifo_dequeue_drop_all (s->tx_fifo);
1571 s->session_state = SESSION_STATE_CLOSING;
1572 session_program_transport_ctrl_evt (s, SESSION_CTRL_EVT_RESET);
Florin Coras2f8d8fa2018-01-26 06:36:04 -08001573}
1574
1575/**
liuyacan534468e2021-05-09 03:50:40 +00001576 * Notify transport the session can be half-disconnected.
1577 *
1578 * Must be called from the session's thread.
1579 */
1580void
1581session_transport_half_close (session_t *s)
1582{
1583 /* Only READY session can be half-closed */
1584 if (s->session_state != SESSION_STATE_READY)
1585 {
1586 return;
1587 }
1588
1589 transport_half_close (session_get_transport_proto (s), s->connection_index,
1590 s->thread_index);
1591}
1592
1593/**
Florin Coras2f8d8fa2018-01-26 06:36:04 -08001594 * Notify transport the session can be disconnected. This should eventually
1595 * result in a delete notification that allows us to cleanup session state.
1596 * Called for both active/passive disconnects.
1597 *
1598 * Must be called from the session's thread.
1599 */
1600void
Florin Coras288eaab2019-02-03 15:26:14 -08001601session_transport_close (session_t * s)
Florin Coras2f8d8fa2018-01-26 06:36:04 -08001602{
Florin Coras692b9492019-07-12 15:01:53 -07001603 if (s->session_state >= SESSION_STATE_APP_CLOSED)
Florin Coras568ebc72018-09-18 16:12:50 -07001604 {
Florin Coras5f066322019-07-22 19:03:03 -07001605 if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED)
1606 s->session_state = SESSION_STATE_CLOSED;
1607 /* If transport is already deleted, just free the session */
1608 else if (s->session_state >= SESSION_STATE_TRANSPORT_DELETED)
Florin Coras692b9492019-07-12 15:01:53 -07001609 session_free_w_fifos (s);
Florin Coras568ebc72018-09-18 16:12:50 -07001610 return;
1611 }
Florin Coras78cc4b02018-12-20 18:24:49 -08001612
Florin Coras692b9492019-07-12 15:01:53 -07001613 /* If the tx queue wasn't drained, the transport can continue to try
1614 * sending the outstanding data (in closed state it cannot). It MUST however
1615 * at one point, either after sending everything or after a timeout, call
1616 * delete notify. This will finally lead to the complete cleanup of the
1617 * session.
Florin Coras78cc4b02018-12-20 18:24:49 -08001618 */
Florin Coras692b9492019-07-12 15:01:53 -07001619 s->session_state = SESSION_STATE_APP_CLOSED;
Florin Coras78cc4b02018-12-20 18:24:49 -08001620
Florin Coras1ee78302019-02-05 15:51:15 -08001621 transport_close (session_get_transport_proto (s), s->connection_index,
1622 s->thread_index);
Dave Barach68b0fb02017-02-28 15:15:56 -05001623}
1624
1625/**
Florin Corasdfb3b872019-08-16 17:48:44 -07001626 * Force transport close
1627 */
1628void
1629session_transport_reset (session_t * s)
1630{
1631 if (s->session_state >= SESSION_STATE_APP_CLOSED)
1632 {
1633 if (s->session_state == SESSION_STATE_TRANSPORT_CLOSED)
1634 s->session_state = SESSION_STATE_CLOSED;
1635 else if (s->session_state >= SESSION_STATE_TRANSPORT_DELETED)
1636 session_free_w_fifos (s);
1637 return;
1638 }
1639
1640 s->session_state = SESSION_STATE_APP_CLOSED;
1641 transport_reset (session_get_transport_proto (s), s->connection_index,
1642 s->thread_index);
1643}
1644
1645/**
Dave Barach68b0fb02017-02-28 15:15:56 -05001646 * Cleanup transport and session state.
Florin Corasd79b41e2017-03-04 05:37:52 -08001647 *
Florin Coras25579b42018-06-06 17:55:02 -07001648 * Notify transport of the cleanup and free the session. This should
1649 * be called only if transport reported some error and is already
1650 * closed.
Dave Barach68b0fb02017-02-28 15:15:56 -05001651 */
1652void
Florin Coras288eaab2019-02-03 15:26:14 -08001653session_transport_cleanup (session_t * s)
Dave Barach68b0fb02017-02-28 15:15:56 -05001654{
Florin Coras25579b42018-06-06 17:55:02 -07001655 /* Delete from main lookup table before we axe the the transport */
1656 session_lookup_del_session (s);
Florin Coras5afea122019-10-28 08:46:37 -07001657 if (s->session_state != SESSION_STATE_TRANSPORT_DELETED)
1658 transport_cleanup (session_get_transport_proto (s), s->connection_index,
1659 s->thread_index);
Florin Coras25579b42018-06-06 17:55:02 -07001660 /* Since we called cleanup, no delete notification will come. So, make
1661 * sure the session is properly freed. */
Florin Corasd3955fb2019-11-29 09:31:47 -08001662 segment_manager_dealloc_fifos (s->rx_fifo, s->tx_fifo);
1663 session_free (s);
Dave Barach68b0fb02017-02-28 15:15:56 -05001664}
1665
Florin Corasa5464812017-04-19 13:00:05 -07001666/**
Florin Coras8afe1b82021-11-17 23:38:54 -08001667 * Allocate worker mqs in share-able segment
Florin Corasb384b542018-01-15 01:08:33 -08001668 *
Florin Coras8afe1b82021-11-17 23:38:54 -08001669 * That can only be a newly created memfd segment, that must be mapped
1670 * by all apps/stack users unless private rx mqs are enabled.
Florin Corasa5464812017-04-19 13:00:05 -07001671 */
1672void
Florin Coras8afe1b82021-11-17 23:38:54 -08001673session_vpp_wrk_mqs_alloc (session_main_t *smm)
Florin Corasa5464812017-04-19 13:00:05 -07001674{
Florin Coras8afe1b82021-11-17 23:38:54 -08001675 u32 mq_q_length = 2048, evt_size = sizeof (session_event_t);
1676 fifo_segment_t *mqs_seg = &smm->wrk_mqs_segment;
1677 svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
1678 uword mqs_seg_size;
Florin Corasb384b542018-01-15 01:08:33 -08001679 int i;
Florin Corasa5464812017-04-19 13:00:05 -07001680
Florin Coras8afe1b82021-11-17 23:38:54 -08001681 mq_q_length = clib_max (mq_q_length, smm->configured_wrk_mq_length);
Florin Corasb384b542018-01-15 01:08:33 -08001682
Florin Coras8afe1b82021-11-17 23:38:54 -08001683 svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
1684 { mq_q_length, evt_size, 0 }, { mq_q_length >> 1, 256, 0 }
1685 };
1686 cfg->consumer_pid = 0;
1687 cfg->n_rings = 2;
1688 cfg->q_nitems = mq_q_length;
1689 cfg->ring_cfgs = rc;
Florin Coras6c10ab22020-11-08 16:50:39 -08001690
Florin Coras8afe1b82021-11-17 23:38:54 -08001691 /*
1692 * Compute mqs segment size based on rings config and leave space
1693 * for passing extended configuration messages, i.e., data allocated
1694 * outside of the rings. If provided with a config value, accept it
1695 * if larger than minimum size.
1696 */
1697 mqs_seg_size = svm_msg_q_size_to_alloc (cfg) * vec_len (smm->wrk);
1698 mqs_seg_size = mqs_seg_size + (32 << 10);
1699 mqs_seg_size = clib_max (mqs_seg_size, smm->wrk_mqs_segment_size);
1700
1701 mqs_seg->ssvm.ssvm_size = mqs_seg_size;
1702 mqs_seg->ssvm.my_pid = getpid ();
1703 mqs_seg->ssvm.name = format (0, "%s%c", "session: wrk-mqs-segment", 0);
Florin Coras6c10ab22020-11-08 16:50:39 -08001704
Florin Coras8afe1b82021-11-17 23:38:54 -08001705 if (ssvm_server_init (&mqs_seg->ssvm, SSVM_SEGMENT_MEMFD))
Florin Corasa5464812017-04-19 13:00:05 -07001706 {
Florin Coras6c10ab22020-11-08 16:50:39 -08001707 clib_warning ("failed to initialize queue segment");
1708 return;
Florin Corasa5464812017-04-19 13:00:05 -07001709 }
Florin Corasb384b542018-01-15 01:08:33 -08001710
Florin Coras8afe1b82021-11-17 23:38:54 -08001711 fifo_segment_init (mqs_seg);
Florin Corasb384b542018-01-15 01:08:33 -08001712
Florin Corasb4624182020-12-11 13:58:12 -08001713 /* Special fifo segment that's filled only with mqs */
Florin Coras8afe1b82021-11-17 23:38:54 -08001714 mqs_seg->h->n_mqs = vec_len (smm->wrk);
Florin Corasb4624182020-12-11 13:58:12 -08001715
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001716 for (i = 0; i < vec_len (smm->wrk); i++)
Florin Coras8afe1b82021-11-17 23:38:54 -08001717 smm->wrk[i].vpp_event_queue = fifo_segment_msg_q_alloc (mqs_seg, i, cfg);
Florin Corasb384b542018-01-15 01:08:33 -08001718}
1719
Florin Coras04943b42020-12-25 11:45:40 -08001720fifo_segment_t *
Florin Coras8afe1b82021-11-17 23:38:54 -08001721session_main_get_wrk_mqs_segment (void)
Florin Corasb384b542018-01-15 01:08:33 -08001722{
Florin Coras8afe1b82021-11-17 23:38:54 -08001723 return &session_main.wrk_mqs_segment;
Florin Corasa5464812017-04-19 13:00:05 -07001724}
1725
Florin Coras31c99552019-03-01 13:00:58 -08001726u64
1727session_segment_handle (session_t * s)
1728{
1729 svm_fifo_t *f;
1730
Aloys Augustincdb71702019-04-08 17:54:39 +02001731 if (!s->rx_fifo)
Florin Coras31c99552019-03-01 13:00:58 -08001732 return SESSION_INVALID_HANDLE;
1733
1734 f = s->rx_fifo;
1735 return segment_manager_make_segment_handle (f->segment_manager,
1736 f->segment_index);
1737}
1738
Florin Coras371ca502018-02-21 12:07:41 -08001739/* *INDENT-OFF* */
1740static session_fifo_rx_fn *session_tx_fns[TRANSPORT_TX_N_FNS] = {
1741 session_tx_fifo_peek_and_snd,
1742 session_tx_fifo_dequeue_and_snd,
Florin Coras7fb0fe12018-04-09 09:24:52 -07001743 session_tx_fifo_dequeue_internal,
1744 session_tx_fifo_dequeue_and_snd
Florin Coras371ca502018-02-21 12:07:41 -08001745};
1746/* *INDENT-ON* */
1747
Florin Coras561af9b2017-12-09 10:19:43 -08001748void
1749session_register_transport (transport_proto_t transport_proto,
1750 const transport_proto_vft_t * vft, u8 is_ip4,
1751 u32 output_node)
Dave Barach2c25a622017-06-26 11:35:07 -04001752{
Florin Coras31c99552019-03-01 13:00:58 -08001753 session_main_t *smm = &session_main;
Florin Coras561af9b2017-12-09 10:19:43 -08001754 session_type_t session_type;
1755 u32 next_index = ~0;
Dave Barach2c25a622017-06-26 11:35:07 -04001756
Florin Coras561af9b2017-12-09 10:19:43 -08001757 session_type = session_type_from_proto_and_ip (transport_proto, is_ip4);
1758
1759 vec_validate (smm->session_type_to_next, session_type);
Florin Coras561af9b2017-12-09 10:19:43 -08001760 vec_validate (smm->session_tx_fns, session_type);
1761
Florin Coras371ca502018-02-21 12:07:41 -08001762 if (output_node != ~0)
Florin Coraseb839cc2021-04-14 11:23:55 -07001763 next_index = vlib_node_add_next (vlib_get_main (),
1764 session_queue_node.index, output_node);
Florin Coras561af9b2017-12-09 10:19:43 -08001765
1766 smm->session_type_to_next[session_type] = next_index;
Nathan Skrzypczake971bc92019-06-19 13:42:37 +02001767 smm->session_tx_fns[session_type] =
1768 session_tx_fns[vft->transport_options.tx_type];
Dave Barach2c25a622017-06-26 11:35:07 -04001769}
1770
Florin Coras5384cca2022-01-20 18:10:26 -08001771void
1772session_register_update_time_fn (session_update_time_fn fn, u8 is_add)
1773{
1774 session_main_t *smm = &session_main;
1775 session_update_time_fn *fi;
1776 u32 fi_pos = ~0;
1777 u8 found = 0;
1778
1779 vec_foreach (fi, smm->update_time_fns)
1780 {
1781 if (*fi == fn)
1782 {
1783 fi_pos = fi - smm->update_time_fns;
1784 found = 1;
1785 break;
1786 }
1787 }
1788
1789 if (is_add)
1790 {
1791 if (found)
1792 {
1793 clib_warning ("update time fn %p already registered", fn);
1794 return;
1795 }
1796 vec_add1 (smm->update_time_fns, fn);
1797 }
1798 else
1799 {
1800 vec_del1 (smm->update_time_fns, fi_pos);
1801 }
1802}
1803
Florin Coras07063b82020-03-13 04:44:51 +00001804transport_proto_t
1805session_add_transport_proto (void)
1806{
1807 session_main_t *smm = &session_main;
1808 session_worker_t *wrk;
1809 u32 thread;
1810
1811 smm->last_transport_proto_type += 1;
1812
1813 for (thread = 0; thread < vec_len (smm->wrk); thread++)
1814 {
1815 wrk = session_main_get_worker (thread);
1816 vec_validate (wrk->session_to_enqueue, smm->last_transport_proto_type);
1817 }
1818
1819 return smm->last_transport_proto_type;
1820}
1821
Florin Coras3cbc04b2017-10-02 00:18:51 -07001822transport_connection_t *
Florin Coras288eaab2019-02-03 15:26:14 -08001823session_get_transport (session_t * s)
Florin Coras3cbc04b2017-10-02 00:18:51 -07001824{
Florin Corasade70e42017-10-14 18:56:41 -07001825 if (s->session_state != SESSION_STATE_LISTENING)
Florin Coras4edc37e2019-02-04 23:01:34 -08001826 return transport_get_connection (session_get_transport_proto (s),
1827 s->connection_index, s->thread_index);
1828 else
1829 return transport_get_listener (session_get_transport_proto (s),
1830 s->connection_index);
Florin Coras3cbc04b2017-10-02 00:18:51 -07001831}
1832
Aloys Augustincdb71702019-04-08 17:54:39 +02001833void
Florin Coras09d18c22019-04-24 11:10:02 -07001834session_get_endpoint (session_t * s, transport_endpoint_t * tep, u8 is_lcl)
Aloys Augustincdb71702019-04-08 17:54:39 +02001835{
1836 if (s->session_state != SESSION_STATE_LISTENING)
1837 return transport_get_endpoint (session_get_transport_proto (s),
Florin Coras09d18c22019-04-24 11:10:02 -07001838 s->connection_index, s->thread_index, tep,
1839 is_lcl);
Aloys Augustincdb71702019-04-08 17:54:39 +02001840 else
1841 return transport_get_listener_endpoint (session_get_transport_proto (s),
Florin Coras09d18c22019-04-24 11:10:02 -07001842 s->connection_index, tep, is_lcl);
Aloys Augustincdb71702019-04-08 17:54:39 +02001843}
1844
Florin Coras04ae8272021-04-12 19:55:37 -07001845int
1846session_transport_attribute (session_t *s, u8 is_get,
1847 transport_endpt_attr_t *attr)
1848{
1849 if (s->session_state < SESSION_STATE_READY)
1850 return -1;
1851
1852 return transport_connection_attribute (session_get_transport_proto (s),
1853 s->connection_index, s->thread_index,
1854 is_get, attr);
1855}
1856
Florin Coras3cbc04b2017-10-02 00:18:51 -07001857transport_connection_t *
Florin Coras288eaab2019-02-03 15:26:14 -08001858listen_session_get_transport (session_t * s)
Florin Coras3cbc04b2017-10-02 00:18:51 -07001859{
Florin Coras4edc37e2019-02-04 23:01:34 -08001860 return transport_get_listener (session_get_transport_proto (s),
1861 s->connection_index);
Florin Coras3cbc04b2017-10-02 00:18:51 -07001862}
1863
Florin Corasfd542f12018-05-16 19:28:24 -07001864void
Florin Coras5484daa2020-03-27 23:55:06 +00001865session_queue_run_on_main_thread (vlib_main_t * vm)
Florin Corasfd542f12018-05-16 19:28:24 -07001866{
1867 ASSERT (vlib_get_thread_index () == 0);
Florin Coras1d2e38b2021-03-17 21:52:49 -07001868 vlib_node_set_interrupt_pending (vm, session_queue_node.index);
Florin Corasfd542f12018-05-16 19:28:24 -07001869}
1870
Dave Barach68b0fb02017-02-28 15:15:56 -05001871static clib_error_t *
Florin Corase04c2992017-03-01 08:17:34 -08001872session_manager_main_enable (vlib_main_t * vm)
Dave Barach68b0fb02017-02-28 15:15:56 -05001873{
Florin Coras31c99552019-03-01 13:00:58 -08001874 session_main_t *smm = &session_main;
Florin Corase04c2992017-03-01 08:17:34 -08001875 vlib_thread_main_t *vtm = vlib_get_thread_main ();
Florin Coras371ca502018-02-21 12:07:41 -08001876 u32 num_threads, preallocated_sessions_per_worker;
Florin Coras31c99552019-03-01 13:00:58 -08001877 session_worker_t *wrk;
Florin Corasd5c604d2019-03-18 09:06:35 -07001878 int i;
Dave Barach68b0fb02017-02-28 15:15:56 -05001879
Florin Corase10da622020-10-25 14:00:29 -07001880 /* We only initialize once and do not de-initialized on disable */
1881 if (smm->is_initialized)
1882 goto done;
1883
Dave Barach68b0fb02017-02-28 15:15:56 -05001884 num_threads = 1 /* main thread */ + vtm->n_threads;
1885
1886 if (num_threads < 1)
1887 return clib_error_return (0, "n_thread_stacks not set");
1888
Florin Coras5f56d732018-10-30 10:21:59 -07001889 /* Allocate cache line aligned worker contexts */
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001890 vec_validate_aligned (smm->wrk, num_threads - 1, CLIB_CACHE_LINE_BYTES);
Florin Coras3cbc04b2017-10-02 00:18:51 -07001891
Dave Barachacd2a6a2017-05-16 17:41:34 -04001892 for (i = 0; i < num_threads; i++)
1893 {
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001894 wrk = &smm->wrk[i];
Florin Corasb0ffbee2019-07-21 19:23:46 -07001895 wrk->ctrl_head = clib_llist_make_head (wrk->event_elts, evt_list);
Florin Coras2062ec02019-07-15 13:15:18 -07001896 wrk->new_head = clib_llist_make_head (wrk->event_elts, evt_list);
Florin Coras60183db2019-07-20 15:53:16 -07001897 wrk->old_head = clib_llist_make_head (wrk->event_elts, evt_list);
Florin Corasaf972212021-05-05 09:54:00 -07001898 wrk->pending_connects = clib_llist_make_head (wrk->event_elts, evt_list);
Damjan Marion6ffb7c62021-03-26 13:06:13 +01001899 wrk->vm = vlib_get_main_by_index (i);
Dave Barach77d98382020-04-28 18:00:21 -04001900 wrk->last_vlib_time = vlib_time_now (vm);
Florin Corasa8e71c82019-10-22 19:01:39 -07001901 wrk->last_vlib_us_time = wrk->last_vlib_time * CLIB_US_TIME_FREQ;
Florin Corasa48dffe2021-05-16 10:58:53 -07001902 wrk->timerfd = -1;
Florin Coras07063b82020-03-13 04:44:51 +00001903 vec_validate (wrk->session_to_enqueue, smm->last_transport_proto_type);
Florin Corasd67f1122018-05-21 17:47:40 -07001904
Florin Coras29ca16f2017-11-02 18:14:17 -04001905 if (num_threads > 1)
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001906 clib_rwlock_init (&smm->wrk[i].peekers_rw_locks);
Florin Coras7da88292021-03-18 15:04:34 -07001907
1908 if (!smm->no_adaptive && smm->use_private_rx_mqs)
1909 session_wrk_enable_adaptive_mode (wrk);
Dave Barachacd2a6a2017-05-16 17:41:34 -04001910 }
1911
Florin Corasb384b542018-01-15 01:08:33 -08001912 /* Allocate vpp event queues segment and queue */
Florin Coras8afe1b82021-11-17 23:38:54 -08001913 session_vpp_wrk_mqs_alloc (smm);
Florin Corasb384b542018-01-15 01:08:33 -08001914
Florin Coras9a45bd82020-12-28 16:28:07 -08001915 /* Initialize segment manager properties */
1916 segment_manager_main_init ();
Florin Coras6cf30ad2017-04-04 23:08:23 -07001917
Florin Coras66b11312017-07-31 17:18:03 -07001918 /* Preallocate sessions */
Dave Barachb7f1faa2017-08-29 11:43:37 -04001919 if (smm->preallocated_sessions)
Dave Barach68b0fb02017-02-28 15:15:56 -05001920 {
Dave Barachb7f1faa2017-08-29 11:43:37 -04001921 if (num_threads == 1)
Florin Coras66b11312017-07-31 17:18:03 -07001922 {
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001923 pool_init_fixed (smm->wrk[0].sessions, smm->preallocated_sessions);
Florin Coras66b11312017-07-31 17:18:03 -07001924 }
Dave Barachb7f1faa2017-08-29 11:43:37 -04001925 else
Florin Coras66b11312017-07-31 17:18:03 -07001926 {
Dave Barachb7f1faa2017-08-29 11:43:37 -04001927 int j;
1928 preallocated_sessions_per_worker =
1929 (1.1 * (f64) smm->preallocated_sessions /
1930 (f64) (num_threads - 1));
1931
1932 for (j = 1; j < num_threads; j++)
Florin Coras66b11312017-07-31 17:18:03 -07001933 {
Florin Coras5a7ca7b2018-10-30 12:01:48 -07001934 pool_init_fixed (smm->wrk[j].sessions,
Dave Barachb7f1faa2017-08-29 11:43:37 -04001935 preallocated_sessions_per_worker);
Florin Coras66b11312017-07-31 17:18:03 -07001936 }
Florin Coras66b11312017-07-31 17:18:03 -07001937 }
1938 }
Dave Barach68b0fb02017-02-28 15:15:56 -05001939
Florin Coras04e53442017-07-16 17:12:15 -07001940 session_lookup_init ();
Florin Corascea194d2017-10-02 00:18:51 -07001941 app_namespaces_init ();
Florin Coras3cbc04b2017-10-02 00:18:51 -07001942 transport_init ();
Florin Corase10da622020-10-25 14:00:29 -07001943 smm->is_initialized = 1;
1944
1945done:
Dave Barach68b0fb02017-02-28 15:15:56 -05001946
Florin Corase04c2992017-03-01 08:17:34 -08001947 smm->is_enabled = 1;
1948
Florin Coras561af9b2017-12-09 10:19:43 -08001949 /* Enable transports */
1950 transport_enable_disable (vm, 1);
Florin Coras11166672020-04-13 01:20:25 +00001951 session_debug_init ();
Srikanth Akula73570432020-04-06 19:19:49 -07001952
Dave Barach68b0fb02017-02-28 15:15:56 -05001953 return 0;
1954}
1955
Florin Corase10da622020-10-25 14:00:29 -07001956static void
1957session_manager_main_disable (vlib_main_t * vm)
1958{
1959 transport_enable_disable (vm, 0 /* is_en */ );
1960}
1961
Florin Corasa5464812017-04-19 13:00:05 -07001962void
1963session_node_enable_disable (u8 is_en)
1964{
Florin Coras1d2e38b2021-03-17 21:52:49 -07001965 u8 mstate = is_en ? VLIB_NODE_STATE_INTERRUPT : VLIB_NODE_STATE_DISABLED;
Florin Corasa5464812017-04-19 13:00:05 -07001966 u8 state = is_en ? VLIB_NODE_STATE_POLLING : VLIB_NODE_STATE_DISABLED;
Florin Coras1d2e38b2021-03-17 21:52:49 -07001967 session_main_t *sm = &session_main;
1968 vlib_main_t *vm;
1969 vlib_node_t *n;
1970 int n_vlibs, i;
Florin Corasfd542f12018-05-16 19:28:24 -07001971
Florin Coras1d2e38b2021-03-17 21:52:49 -07001972 n_vlibs = vlib_get_n_threads ();
1973 for (i = 0; i < n_vlibs; i++)
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001974 {
Florin Coras1d2e38b2021-03-17 21:52:49 -07001975 vm = vlib_get_main_by_index (i);
1976 /* main thread with workers and not polling */
1977 if (i == 0 && n_vlibs > 1)
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001978 {
Florin Coras1d2e38b2021-03-17 21:52:49 -07001979 vlib_node_set_state (vm, session_queue_node.index, mstate);
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001980 if (is_en)
1981 {
Florin Corasb32af352021-05-19 07:58:49 -07001982 session_main_get_worker (0)->state = SESSION_WRK_INTERRUPT;
Florin Coras1d2e38b2021-03-17 21:52:49 -07001983 vlib_node_set_state (vm, session_queue_process_node.index,
1984 state);
1985 n = vlib_get_node (vm, session_queue_process_node.index);
1986 vlib_start_process (vm, n->runtime_index);
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001987 }
1988 else
1989 {
Florin Coras1d2e38b2021-03-17 21:52:49 -07001990 vlib_process_signal_event_mt (vm,
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001991 session_queue_process_node.index,
1992 SESSION_Q_PROCESS_STOP, 0);
1993 }
Florin Coras1d2e38b2021-03-17 21:52:49 -07001994 if (!sm->poll_main)
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001995 continue;
1996 }
Florin Coras1d2e38b2021-03-17 21:52:49 -07001997 vlib_node_set_state (vm, session_queue_node.index, state);
Damjan Marion92ccf9b2021-03-26 11:38:01 +01001998 }
Florin Coras41d5f542021-01-15 13:49:33 -08001999
Florin Coras1d2e38b2021-03-17 21:52:49 -07002000 if (sm->use_private_rx_mqs)
Florin Coras41d5f542021-01-15 13:49:33 -08002001 application_enable_rx_mqs_nodes (is_en);
Florin Corasa5464812017-04-19 13:00:05 -07002002}
2003
Florin Corase04c2992017-03-01 08:17:34 -08002004clib_error_t *
2005vnet_session_enable_disable (vlib_main_t * vm, u8 is_en)
2006{
Florin Corascea194d2017-10-02 00:18:51 -07002007 clib_error_t *error = 0;
Florin Corase04c2992017-03-01 08:17:34 -08002008 if (is_en)
2009 {
Florin Coras31c99552019-03-01 13:00:58 -08002010 if (session_main.is_enabled)
Florin Corase04c2992017-03-01 08:17:34 -08002011 return 0;
Dave Barach68b0fb02017-02-28 15:15:56 -05002012
Florin Corascea194d2017-10-02 00:18:51 -07002013 error = session_manager_main_enable (vm);
Vladimir Kropyleva2e44512019-07-16 21:32:41 +03002014 session_node_enable_disable (is_en);
Florin Corase04c2992017-03-01 08:17:34 -08002015 }
2016 else
2017 {
Florin Coras31c99552019-03-01 13:00:58 -08002018 session_main.is_enabled = 0;
Florin Corase10da622020-10-25 14:00:29 -07002019 session_manager_main_disable (vm);
Florin Corasa5464812017-04-19 13:00:05 -07002020 session_node_enable_disable (is_en);
Florin Corase04c2992017-03-01 08:17:34 -08002021 }
2022
Florin Corascea194d2017-10-02 00:18:51 -07002023 return error;
Florin Corase04c2992017-03-01 08:17:34 -08002024}
2025
Florin Corase04c2992017-03-01 08:17:34 -08002026clib_error_t *
Florin Corase33c0022020-04-03 17:23:42 +00002027session_main_init (vlib_main_t * vm)
Florin Corase04c2992017-03-01 08:17:34 -08002028{
Florin Coras31c99552019-03-01 13:00:58 -08002029 session_main_t *smm = &session_main;
Florin Corase33c0022020-04-03 17:23:42 +00002030
2031 smm->is_enabled = 0;
2032 smm->session_enable_asap = 0;
Florin Corase92c9462020-11-25 08:44:16 -08002033 smm->poll_main = 0;
Florin Coras41d5f542021-01-15 13:49:33 -08002034 smm->use_private_rx_mqs = 0;
Florin Coras7da88292021-03-18 15:04:34 -07002035 smm->no_adaptive = 0;
Florin Coras0b656212022-01-13 11:59:44 -08002036 smm->last_transport_proto_type = TRANSPORT_PROTO_HTTP;
Florin Corase33c0022020-04-03 17:23:42 +00002037
Nathan Skrzypczak31bd0352019-11-07 17:55:01 +01002038 return 0;
2039}
2040
2041static clib_error_t *
Florin Corase33c0022020-04-03 17:23:42 +00002042session_main_loop_init (vlib_main_t * vm)
Nathan Skrzypczak31bd0352019-11-07 17:55:01 +01002043{
2044 session_main_t *smm = &session_main;
2045 if (smm->session_enable_asap)
2046 {
2047 vlib_worker_thread_barrier_sync (vm);
2048 vnet_session_enable_disable (vm, 1 /* is_en */ );
2049 vlib_worker_thread_barrier_release (vm);
2050 }
Florin Corase04c2992017-03-01 08:17:34 -08002051 return 0;
2052}
2053
Florin Corase33c0022020-04-03 17:23:42 +00002054VLIB_INIT_FUNCTION (session_main_init);
2055VLIB_MAIN_LOOP_ENTER_FUNCTION (session_main_loop_init);
Dave Barach2c25a622017-06-26 11:35:07 -04002056
2057static clib_error_t *
2058session_config_fn (vlib_main_t * vm, unformat_input_t * input)
Dave Barach10d8cc62017-05-30 09:30:07 -04002059{
Florin Coras31c99552019-03-01 13:00:58 -08002060 session_main_t *smm = &session_main;
Dave Barach10d8cc62017-05-30 09:30:07 -04002061 u32 nitems;
Florin Coras66b11312017-07-31 17:18:03 -07002062 uword tmp;
Dave Barach10d8cc62017-05-30 09:30:07 -04002063
2064 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2065 {
Florin Coras8afe1b82021-11-17 23:38:54 -08002066 if (unformat (input, "wrk-mq-length %d", &nitems))
Dave Barach10d8cc62017-05-30 09:30:07 -04002067 {
2068 if (nitems >= 2048)
Florin Coras8afe1b82021-11-17 23:38:54 -08002069 smm->configured_wrk_mq_length = nitems;
Dave Barach10d8cc62017-05-30 09:30:07 -04002070 else
2071 clib_warning ("event queue length %d too small, ignored", nitems);
2072 }
Florin Coras66b11312017-07-31 17:18:03 -07002073 else if (unformat (input, "preallocated-sessions %d",
2074 &smm->preallocated_sessions))
Dave Barach2c25a622017-06-26 11:35:07 -04002075 ;
Florin Coras66b11312017-07-31 17:18:03 -07002076 else if (unformat (input, "v4-session-table-buckets %d",
2077 &smm->configured_v4_session_table_buckets))
2078 ;
2079 else if (unformat (input, "v4-halfopen-table-buckets %d",
2080 &smm->configured_v4_halfopen_table_buckets))
2081 ;
2082 else if (unformat (input, "v6-session-table-buckets %d",
2083 &smm->configured_v6_session_table_buckets))
2084 ;
2085 else if (unformat (input, "v6-halfopen-table-buckets %d",
2086 &smm->configured_v6_halfopen_table_buckets))
2087 ;
2088 else if (unformat (input, "v4-session-table-memory %U",
2089 unformat_memory_size, &tmp))
2090 {
2091 if (tmp >= 0x100000000)
2092 return clib_error_return (0, "memory size %llx (%lld) too large",
2093 tmp, tmp);
2094 smm->configured_v4_session_table_memory = tmp;
2095 }
2096 else if (unformat (input, "v4-halfopen-table-memory %U",
2097 unformat_memory_size, &tmp))
2098 {
2099 if (tmp >= 0x100000000)
2100 return clib_error_return (0, "memory size %llx (%lld) too large",
2101 tmp, tmp);
2102 smm->configured_v4_halfopen_table_memory = tmp;
2103 }
2104 else if (unformat (input, "v6-session-table-memory %U",
2105 unformat_memory_size, &tmp))
2106 {
2107 if (tmp >= 0x100000000)
2108 return clib_error_return (0, "memory size %llx (%lld) too large",
2109 tmp, tmp);
2110 smm->configured_v6_session_table_memory = tmp;
2111 }
2112 else if (unformat (input, "v6-halfopen-table-memory %U",
2113 unformat_memory_size, &tmp))
2114 {
2115 if (tmp >= 0x100000000)
2116 return clib_error_return (0, "memory size %llx (%lld) too large",
2117 tmp, tmp);
2118 smm->configured_v6_halfopen_table_memory = tmp;
2119 }
Florin Coras93e65802017-11-29 00:07:11 -05002120 else if (unformat (input, "local-endpoints-table-memory %U",
2121 unformat_memory_size, &tmp))
2122 {
2123 if (tmp >= 0x100000000)
2124 return clib_error_return (0, "memory size %llx (%lld) too large",
2125 tmp, tmp);
2126 smm->local_endpoints_table_memory = tmp;
2127 }
2128 else if (unformat (input, "local-endpoints-table-buckets %d",
2129 &smm->local_endpoints_table_buckets))
2130 ;
Nathan Skrzypczak1292d192019-09-13 15:44:54 +02002131 else if (unformat (input, "enable"))
Nathan Skrzypczak31bd0352019-11-07 17:55:01 +01002132 smm->session_enable_asap = 1;
Florin Coras61ae0562020-09-02 19:10:28 -07002133 else if (unformat (input, "use-app-socket-api"))
Nathan Skrzypczak7b3a3df2021-07-28 14:09:50 +02002134 (void) appns_sapi_enable_disable (1 /* is_enable */);
Florin Corase92c9462020-11-25 08:44:16 -08002135 else if (unformat (input, "poll-main"))
2136 smm->poll_main = 1;
Florin Coras41d5f542021-01-15 13:49:33 -08002137 else if (unformat (input, "use-private-rx-mqs"))
2138 smm->use_private_rx_mqs = 1;
Florin Coras7da88292021-03-18 15:04:34 -07002139 else if (unformat (input, "no-adaptive"))
2140 smm->no_adaptive = 1;
Florin Coras8afe1b82021-11-17 23:38:54 -08002141 /*
2142 * Deprecated but maintained for compatibility
2143 */
2144 else if (unformat (input, "evt_qs_memfd_seg"))
2145 ;
Florin Corasef048032021-11-17 23:57:30 -08002146 else if (unformat (input, "segment-baseva 0x%lx", &tmp))
2147 ;
Florin Coras8afe1b82021-11-17 23:38:54 -08002148 else if (unformat (input, "evt_qs_seg_size %U", unformat_memory_size,
2149 &tmp))
2150 ;
2151 else if (unformat (input, "event-queue-length %d", &nitems))
2152 {
2153 if (nitems >= 2048)
2154 smm->configured_wrk_mq_length = nitems;
2155 else
2156 clib_warning ("event queue length %d too small, ignored", nitems);
2157 }
Dave Barach10d8cc62017-05-30 09:30:07 -04002158 else
2159 return clib_error_return (0, "unknown input `%U'",
2160 format_unformat_error, input);
2161 }
2162 return 0;
2163}
2164
2165VLIB_CONFIG_FUNCTION (session_config_fn, "session");
2166
Dave Barach68b0fb02017-02-28 15:15:56 -05002167/*
2168 * fd.io coding-style-patch-verification: ON
2169 *
2170 * Local Variables:
2171 * eval: (c-set-style "gnu")
2172 * End:
2173 */