blob: 1ac9691ad787178ee4d9c6b1c5bffd416317aad1 [file] [log] [blame]
Florin Coras697faea2018-06-27 17:10:49 -07001/*
Florin Coras5e062572019-03-14 19:07:51 -07002 * Copyright (c) 2018-2019 Cisco and/or its affiliates.
Florin Coras697faea2018-06-27 17:10:49 -07003 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this
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#ifndef SRC_VCL_VCL_PRIVATE_H_
17#define SRC_VCL_VCL_PRIVATE_H_
18
19#include <vnet/session/application_interface.h>
20#include <vcl/vppcom.h>
Florin Coras697faea2018-06-27 17:10:49 -070021#include <vcl/vcl_debug.h>
22
23#if (CLIB_DEBUG > 0)
24/* Set VPPCOM_DEBUG_INIT 2 for connection debug,
25 * 3 for read/write debug output
26 * or
27 * export VCL_DEBUG=<#> to set dynamically.
28 */
29#define VPPCOM_DEBUG_INIT 1
30#else
31#define VPPCOM_DEBUG_INIT 0
32#endif
33
34#define VPPCOM_DEBUG vcm->debug
35
Florin Coras134a9962018-08-28 11:32:04 -070036extern __thread uword __vcl_worker_index;
37
38static inline void
39vcl_set_worker_index (uword wrk_index)
40{
41 __vcl_worker_index = wrk_index;
42}
43
44static inline uword
45vcl_get_worker_index (void)
46{
47 return __vcl_worker_index;
48}
49
Florin Coras697faea2018-06-27 17:10:49 -070050/*
51 * VPPCOM Private definitions and functions.
52 */
53typedef enum
54{
55 STATE_APP_START,
56 STATE_APP_CONN_VPP,
57 STATE_APP_ENABLED,
58 STATE_APP_ATTACHED,
Florin Coras134a9962018-08-28 11:32:04 -070059 STATE_APP_ADDING_WORKER,
Florin Coras458089b2019-08-21 16:20:44 -070060 STATE_APP_ADDING_TLS_DATA,
Florin Coras134a9962018-08-28 11:32:04 -070061 STATE_APP_FAILED,
62 STATE_APP_READY
Florin Corasb88de902020-09-08 16:47:57 -070063} vcl_bapi_app_state_t;
Florin Coras697faea2018-06-27 17:10:49 -070064
Florin Corasc127d5a2020-10-14 16:35:58 -070065typedef enum vcl_session_state_
Florin Coras697faea2018-06-27 17:10:49 -070066{
Florin Corasc127d5a2020-10-14 16:35:58 -070067 VCL_STATE_CLOSED,
Florin Corasc127d5a2020-10-14 16:35:58 -070068 VCL_STATE_LISTEN,
Florin Corasdfffdd72020-10-15 10:54:47 -070069 VCL_STATE_READY,
Florin Corasc127d5a2020-10-14 16:35:58 -070070 VCL_STATE_VPP_CLOSING,
71 VCL_STATE_DISCONNECT,
72 VCL_STATE_DETACHED,
73 VCL_STATE_UPDATED,
74 VCL_STATE_LISTEN_NO_MQ,
Florin Coras288eaab2019-02-03 15:26:14 -080075} vcl_session_state_t;
Florin Coras697faea2018-06-27 17:10:49 -070076
Florin Coras697faea2018-06-27 17:10:49 -070077typedef struct epoll_event vppcom_epoll_event_t;
78
79typedef struct
80{
Florin Coras134a9962018-08-28 11:32:04 -070081 u32 next_sh;
82 u32 prev_sh;
83 u32 vep_sh;
Florin Coras697faea2018-06-27 17:10:49 -070084 vppcom_epoll_event_t ev;
85#define VEP_DEFAULT_ET_MASK (EPOLLIN|EPOLLOUT)
86#define VEP_UNSUPPORTED_EVENTS (EPOLLONESHOT|EPOLLEXCLUSIVE)
87 u32 et_mask;
88} vppcom_epoll_t;
89
Florin Coras294afe22019-01-07 17:49:17 -080090/* Select uses the vcl_si_set as if a clib_bitmap. Make sure they are the
91 * same size */
92STATIC_ASSERT (sizeof (clib_bitmap_t) == sizeof (vcl_si_set),
93 "vppcom bitmap size mismatch");
94
Florin Coras697faea2018-06-27 17:10:49 -070095typedef struct
96{
97 u8 is_ip4;
98 ip46_address_t ip46;
99} vppcom_ip46_t;
100
Florin Coras3c7d4f92018-12-14 11:28:43 -0800101#define VCL_ACCEPTED_F_CLOSED (1 << 0)
102#define VCL_ACCEPTED_F_RESET (1 << 1)
103
Florin Coras54693d22018-07-17 10:46:29 -0700104typedef struct vcl_session_msg
105{
Florin Coras54693d22018-07-17 10:46:29 -0700106 union
107 {
108 session_accepted_msg_t accepted_msg;
109 };
Florin Coras3c7d4f92018-12-14 11:28:43 -0800110 u32 flags;
Florin Coras54693d22018-07-17 10:46:29 -0700111} vcl_session_msg_t;
112
BenoƮt Ganne47727c02019-02-12 13:35:08 +0100113typedef enum
Florin Coras697faea2018-06-27 17:10:49 -0700114{
115 VCL_SESS_ATTR_SERVER,
116 VCL_SESS_ATTR_CUT_THRU,
117 VCL_SESS_ATTR_VEP,
118 VCL_SESS_ATTR_VEP_SESSION,
119 VCL_SESS_ATTR_LISTEN, // SOL_SOCKET,SO_ACCEPTCONN
120 VCL_SESS_ATTR_NONBLOCK, // fcntl,O_NONBLOCK
121 VCL_SESS_ATTR_REUSEADDR, // SOL_SOCKET,SO_REUSEADDR
122 VCL_SESS_ATTR_REUSEPORT, // SOL_SOCKET,SO_REUSEPORT
123 VCL_SESS_ATTR_BROADCAST, // SOL_SOCKET,SO_BROADCAST
124 VCL_SESS_ATTR_V6ONLY, // SOL_TCP,IPV6_V6ONLY
125 VCL_SESS_ATTR_KEEPALIVE, // SOL_SOCKET,SO_KEEPALIVE
126 VCL_SESS_ATTR_TCP_NODELAY, // SOL_TCP,TCP_NODELAY
127 VCL_SESS_ATTR_TCP_KEEPIDLE, // SOL_TCP,TCP_KEEPIDLE
128 VCL_SESS_ATTR_TCP_KEEPINTVL, // SOL_TCP,TCP_KEEPINTVL
Florin Coras7baeb712019-01-04 17:05:43 -0800129 VCL_SESS_ATTR_SHUT_RD,
130 VCL_SESS_ATTR_SHUT_WR,
Florin Coras697faea2018-06-27 17:10:49 -0700131 VCL_SESS_ATTR_MAX
132} vppcom_session_attr_t;
133
Florin Coras0a1e1832020-03-29 18:54:04 +0000134typedef enum vcl_session_flags_
135{
Florin Corasd85666f2020-04-03 00:58:48 +0000136 VCL_SESSION_F_CONNECTED = 1 << 0,
Florin Coras6c3b2182020-10-19 18:36:48 -0700137 VCL_SESSION_F_IS_VEP = 1 << 1,
138 VCL_SESSION_F_IS_VEP_SESSION = 1 << 2,
Florin Corasac422d62020-10-19 20:51:36 -0700139 VCL_SESSION_F_HAS_RX_EVT = 1 << 3,
Florin Coras0a1e1832020-03-29 18:54:04 +0000140} __clib_packed vcl_session_flags_t;
141
Florin Corasac422d62020-10-19 20:51:36 -0700142typedef struct vcl_session_
Florin Coras697faea2018-06-27 17:10:49 -0700143{
Florin Coras2cba8532018-09-11 16:33:36 -0700144 CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
Florin Corasac422d62020-10-19 20:51:36 -0700145
Florin Coras697faea2018-06-27 17:10:49 -0700146#define _(type, name) type name;
147 foreach_app_session_field
148#undef _
Florin Corasac422d62020-10-19 20:51:36 -0700149 vcl_session_flags_t flags; /**< see @ref vcl_session_flags_t */
150 u32 rx_bytes_pending; /**< bytes rx-ed as segs but not yet freed */
Florin Coras697faea2018-06-27 17:10:49 -0700151
Florin Coras653e43f2019-03-04 10:56:23 -0800152 svm_fifo_t *ct_rx_fifo;
153 svm_fifo_t *ct_tx_fifo;
Florin Coras54693d22018-07-17 10:46:29 -0700154 vcl_session_msg_t *accept_evts_fifo;
Florin Corasac422d62020-10-19 20:51:36 -0700155
156 u64 vpp_handle;
Florin Corasa5a9efd2021-01-05 17:03:29 -0800157 u64 parent_handle;
Florin Corasac422d62020-10-19 20:51:36 -0700158 u32 listener_index; /**< index of parent listener (if any) */
159 int n_accepted_sessions; /**< sessions accepted by this listener */
Florin Corasac422d62020-10-19 20:51:36 -0700160 vppcom_epoll_t vep;
Florin Corasa5a9efd2021-01-05 17:03:29 -0800161 u32 attributes; /**< see @ref vppcom_session_attr_t */
162 int libc_epfd;
163 u32 ckpair_index;
Florin Coras6a6555a2021-01-28 11:39:27 -0800164 u32 vrf;
Florin Corasac422d62020-10-19 20:51:36 -0700165
166 u32 sndbuf_size; // VPP-TBD: Hack until support setsockopt(SO_SNDBUF)
167 u32 rcvbuf_size; // VPP-TBD: Hack until support setsockopt(SO_RCVBUF)
168 u32 user_mss; // VPP-TBD: Hack until support setsockopt(TCP_MAXSEG)
169
Florin Coras697faea2018-06-27 17:10:49 -0700170#if VCL_ELOG
171 elog_track_t elog_track;
172#endif
173} vcl_session_t;
174
175typedef struct vppcom_cfg_t_
176{
David Johnsond9818dd2018-12-14 14:53:41 -0500177 uword heapsize;
Florin Coras134a9962018-08-28 11:32:04 -0700178 u32 max_workers;
David Johnsond9818dd2018-12-14 14:53:41 -0500179 uword segment_baseva;
Florin Corasd18528f2020-03-27 18:41:54 +0000180 uword segment_size;
181 uword add_segment_size;
Florin Coras697faea2018-06-27 17:10:49 -0700182 u32 preallocated_fifo_pairs;
183 u32 rx_fifo_size;
184 u32 tx_fifo_size;
185 u32 event_queue_size;
186 u32 listen_queue_size;
187 u8 app_proxy_transport_tcp;
188 u8 app_proxy_transport_udp;
189 u8 app_scope_local;
190 u8 app_scope_global;
191 u8 *namespace_id;
192 u64 namespace_secret;
Florin Coras99368312018-08-02 10:45:44 -0700193 u8 use_mq_eventfd;
Florin Coras697faea2018-06-27 17:10:49 -0700194 f64 app_timeout;
195 f64 session_timeout;
196 f64 accept_timeout;
197 u32 event_ring_size;
198 char *event_log_path;
Florin Coras935ce752020-09-08 22:43:47 -0700199 u8 *vpp_app_socket_api; /**< app socket api socket file name */
Florin Corasb88de902020-09-08 16:47:57 -0700200 u8 *vpp_bapi_socket_name; /**< bapi socket transport socket name */
Florin Corasd747c3c2019-10-20 19:55:56 -0700201 u32 tls_engine;
Florin Corasff40d8f2020-08-11 22:05:28 -0700202 u8 mt_wrk_supported;
Florin Coras697faea2018-06-27 17:10:49 -0700203} vppcom_cfg_t;
204
205void vppcom_cfg (vppcom_cfg_t * vcl_cfg);
206
Florin Coras54693d22018-07-17 10:46:29 -0700207typedef struct vcl_cut_through_registration_
208{
209 svm_msg_q_t *mq;
Florin Coras99368312018-08-02 10:45:44 -0700210 svm_msg_q_t *peer_mq;
Florin Coras54693d22018-07-17 10:46:29 -0700211 u32 sid;
Florin Coras99368312018-08-02 10:45:44 -0700212 u32 epoll_evt_conn_index; /*< mq evt connection index part of
213 the mqs evtfd epoll (if used) */
Florin Coras54693d22018-07-17 10:46:29 -0700214} vcl_cut_through_registration_t;
215
Florin Coras99368312018-08-02 10:45:44 -0700216typedef struct vcl_mq_evt_conn_
217{
218 svm_msg_q_t *mq;
219 int mq_fd;
220} vcl_mq_evt_conn_t;
221
Florin Coras134a9962018-08-28 11:32:04 -0700222typedef struct vcl_worker_
Florin Coras697faea2018-06-27 17:10:49 -0700223{
Florin Coras134a9962018-08-28 11:32:04 -0700224 CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
Florin Coras697faea2018-06-27 17:10:49 -0700225
Florin Coras697faea2018-06-27 17:10:49 -0700226 /* Session pool */
Florin Coras697faea2018-06-27 17:10:49 -0700227 vcl_session_t *sessions;
228
Florin Coras053a0e42018-11-13 15:52:38 -0800229 /** Worker/thread index in current process */
Florin Coras134a9962018-08-28 11:32:04 -0700230 u32 wrk_index;
231
Florin Coras053a0e42018-11-13 15:52:38 -0800232 /** Worker index in vpp*/
233 u32 vpp_wrk_index;
234
Florin Corascc7c88e2020-09-15 15:56:51 -0700235 /**
236 * Generic api client handle. When binary api is in used, it stores
237 * the "client_index" and when socket api is use, it stores the sapi
238 * client handle */
239 u32 api_client_handle;
Florin Coras47c40e22018-11-26 17:01:36 -0800240
241 /** VPP binary api input queue */
242 svm_queue_t *vl_input_queue;
243
Florin Coras458089b2019-08-21 16:20:44 -0700244 /** VPP mq to be used for exchanging control messages */
245 svm_msg_q_t *ctrl_mq;
246
Florin Coras99368312018-08-02 10:45:44 -0700247 /** Message queues epoll fd. Initialized only if using mqs with eventfds */
248 int mqs_epfd;
249
250 /** Pool of event message queue event connections */
251 vcl_mq_evt_conn_t *mq_evt_conns;
252
253 /** Per worker buffer for receiving mq epoll events */
254 struct epoll_event *mq_events;
255
Florin Coras134a9962018-08-28 11:32:04 -0700256 /** Hash table for disconnect processing */
Florin Coras697faea2018-06-27 17:10:49 -0700257 uword *session_index_by_vpp_handles;
258
Florin Coras134a9962018-08-28 11:32:04 -0700259 /** Select bitmaps */
Florin Coras697faea2018-06-27 17:10:49 -0700260 clib_bitmap_t *rd_bitmap;
261 clib_bitmap_t *wr_bitmap;
262 clib_bitmap_t *ex_bitmap;
263
Florin Coras134a9962018-08-28 11:32:04 -0700264 /** Our event message queue */
Florin Coras3c2fed52018-07-04 04:15:05 -0700265 svm_msg_q_t *app_event_queue;
Florin Coras697faea2018-06-27 17:10:49 -0700266
Florin Coras134a9962018-08-28 11:32:04 -0700267 /** For deadman timers */
Florin Coras697faea2018-06-27 17:10:49 -0700268 clib_time_t clib_time;
269
Florin Coras134a9962018-08-28 11:32:04 -0700270 /** Vector acting as buffer for mq messages */
Florin Coras99368312018-08-02 10:45:44 -0700271 svm_msg_q_msg_t *mq_msg_vector;
Florin Coras3348a4c2018-09-07 17:09:35 -0700272
Florin Coras86f04502018-09-12 16:08:01 -0700273 /** Vector of unhandled events */
274 session_event_t *unhandled_evts_vector;
275
Florin Coras30e79c22019-01-02 19:31:22 -0800276 u32 *pending_session_wrk_updates;
277
Florin Coras3348a4c2018-09-07 17:09:35 -0700278 /** Used also as a thread stop key buffer */
279 pthread_t thread_id;
Florin Coras47c40e22018-11-26 17:01:36 -0800280
281 /** Current pid, may be different from main_pid if forked child */
282 pid_t current_pid;
Florin Coras01f3f892018-12-02 12:45:53 -0800283
284 u32 forked_child;
285
Florin Coras935ce752020-09-08 22:43:47 -0700286 clib_socket_t app_api_sock;
Florin Corasd4c70922019-11-28 14:21:21 -0800287 socket_client_main_t bapi_sock_ctx;
Florin Corasd4c70922019-11-28 14:21:21 -0800288 api_main_t bapi_api_ctx;
Florin Corasfda21c92021-04-07 17:03:01 -0700289 memory_client_main_t bapi_mem_ctx;
hanlina3a48962020-07-13 11:09:15 +0800290
Florin Coras3b6c84c2021-01-05 20:45:44 -0800291 /* State of the connection, shared between msg RX thread and main thread */
292 volatile vcl_bapi_app_state_t bapi_app_state;
Florin Corasa5a9efd2021-01-05 17:03:29 -0800293 volatile uword bapi_return;
Florin Coras3b6c84c2021-01-05 20:45:44 -0800294
hanlina3a48962020-07-13 11:09:15 +0800295 /** vcl needs next epoll_create to go to libc_epoll */
296 u8 vcl_needs_real_epoll;
297 volatile int rpc_done;
Florin Coras134a9962018-08-28 11:32:04 -0700298} vcl_worker_t;
299
Florin Corasb242d312020-10-26 15:35:40 -0700300STATIC_ASSERT (sizeof (session_disconnected_msg_t) <= 16,
301 "disconnected must fit in session_event_t");
302STATIC_ASSERT (sizeof (session_reset_msg_t) <= 16,
303 "disconnected must fit in session_event_t");
304
Florin Coras40c07ce2020-07-16 20:46:17 -0700305typedef void (vcl_rpc_fn_t) (void *args);
306
Florin Coras134a9962018-08-28 11:32:04 -0700307typedef struct vppcom_main_t_
308{
309 u8 is_init;
310 u32 debug;
311 pthread_t main_cpu;
312
Florin Coras053a0e42018-11-13 15:52:38 -0800313 /** Main process pid */
314 pid_t main_pid;
315
Florin Corasc1f5a432018-11-20 11:31:26 -0800316 /** App's index in vpp. It's used by vpp to identify the app */
317 u32 app_index;
Florin Coras134a9962018-08-28 11:32:04 -0700318
Florin Coras053a0e42018-11-13 15:52:38 -0800319 u8 *app_name;
320
Florin Coras134a9962018-08-28 11:32:04 -0700321 /** VCL configuration */
322 vppcom_cfg_t cfg;
Florin Coras99368312018-08-02 10:45:44 -0700323
Florin Coras47c40e22018-11-26 17:01:36 -0800324 volatile u32 forking;
325
Florin Coras134a9962018-08-28 11:32:04 -0700326 /** Workers */
327 vcl_worker_t *workers;
328
Florin Corasde9f08b2018-09-07 14:32:58 -0700329 /** Lock to protect worker registrations */
330 clib_spinlock_t workers_lock;
331
Florin Corasd85de682018-11-29 17:02:29 -0800332 /** Lock to protect segment hash table */
333 clib_rwlock_t segment_table_lock;
334
335 /** Mapped segments table */
336 uword *segment_table;
337
Florin Coras22ba3302019-08-29 22:45:04 -0700338 /** Control mq obtained from attach */
339 svm_msg_q_t *ctrl_mq;
340
Florin Coras88001c62019-04-24 14:44:46 -0700341 fifo_segment_main_t segment_main;
Florin Corasadc74d72018-12-02 13:36:00 -0800342
Florin Corasb88de902020-09-08 16:47:57 -0700343 vcl_rpc_fn_t *wrk_rpc_fn;
344
345 /*
346 * Binary api context
347 */
348
Florin Corasb88de902020-09-08 16:47:57 -0700349 /* VNET_API_ERROR_FOO -> "Foo" hash table */
350 uword *error_string_by_error_number;
351
Florin Coras697faea2018-06-27 17:10:49 -0700352#ifdef VCL_ELOG
353 /* VPP Event-logger */
354 elog_main_t elog_main;
355 elog_track_t elog_track;
356#endif
357
Florin Coras697faea2018-06-27 17:10:49 -0700358} vppcom_main_t;
359
360extern vppcom_main_t *vcm;
Florin Corasce815de2020-04-16 18:47:27 +0000361extern vppcom_main_t _vppcom_main;
Florin Coras697faea2018-06-27 17:10:49 -0700362
Florin Coras54693d22018-07-17 10:46:29 -0700363#define VCL_INVALID_SESSION_INDEX ((u32)~0)
Nathan Skrzypczakcef02be2019-07-17 10:20:45 +0200364#define VCL_INVALID_SESSION_HANDLE ((u64)~0)
Florin Corasd85de682018-11-29 17:02:29 -0800365#define VCL_INVALID_SEGMENT_INDEX ((u32)~0)
366#define VCL_INVALID_SEGMENT_HANDLE ((u64)~0)
Florin Coras54693d22018-07-17 10:46:29 -0700367
Florin Corascbb5e822021-02-20 10:42:22 -0800368void vcl_session_detach_fifos (vcl_session_t *s);
369
Florin Coras54693d22018-07-17 10:46:29 -0700370static inline vcl_session_t *
Florin Coras134a9962018-08-28 11:32:04 -0700371vcl_session_alloc (vcl_worker_t * wrk)
Florin Coras99368312018-08-02 10:45:44 -0700372{
373 vcl_session_t *s;
Florin Coras134a9962018-08-28 11:32:04 -0700374 pool_get (wrk->sessions, s);
Florin Coras99368312018-08-02 10:45:44 -0700375 memset (s, 0, sizeof (*s));
Florin Coras134a9962018-08-28 11:32:04 -0700376 s->session_index = s - wrk->sessions;
Nathan Skrzypczak9fd99622019-05-16 14:38:44 +0200377 s->listener_index = VCL_INVALID_SESSION_INDEX;
Florin Coras99368312018-08-02 10:45:44 -0700378 return s;
379}
380
381static inline void
Florin Coras134a9962018-08-28 11:32:04 -0700382vcl_session_free (vcl_worker_t * wrk, vcl_session_t * s)
Florin Coras99368312018-08-02 10:45:44 -0700383{
Florin Coras243edd52020-03-04 22:20:12 +0000384 /* Debug level set to 1 to avoid debug messages while ldp is cleaning up */
385 VDBG (1, "session %u [0x%llx] removed", s->session_index, s->vpp_handle);
Florin Corascbb5e822021-02-20 10:42:22 -0800386 vcl_session_detach_fifos (s);
Florin Coras134a9962018-08-28 11:32:04 -0700387 pool_put (wrk->sessions, s);
Florin Coras99368312018-08-02 10:45:44 -0700388}
389
390static inline vcl_session_t *
Florin Coras134a9962018-08-28 11:32:04 -0700391vcl_session_get (vcl_worker_t * wrk, u32 session_index)
Florin Coras54693d22018-07-17 10:46:29 -0700392{
Florin Coras134a9962018-08-28 11:32:04 -0700393 if (pool_is_free_index (wrk->sessions, session_index))
Florin Coras54693d22018-07-17 10:46:29 -0700394 return 0;
Florin Coras134a9962018-08-28 11:32:04 -0700395 return pool_elt_at_index (wrk->sessions, session_index);
Florin Coras54693d22018-07-17 10:46:29 -0700396}
397
Florin Corasf9240dc2019-01-15 08:03:17 -0800398static inline vcl_session_handle_t
hanlinf8e13632020-08-21 11:05:36 +0800399vcl_session_handle_from_wrk_session_index (u32 session_index, u32 wrk_index)
400{
401 ASSERT (session_index < 2 << 24);
402 return (wrk_index << 24 | session_index);
403}
404
405static inline vcl_session_handle_t
Florin Corasf9240dc2019-01-15 08:03:17 -0800406vcl_session_handle_from_index (u32 session_index)
407{
408 ASSERT (session_index < 2 << 24);
409 return (vcl_get_worker_index () << 24 | session_index);
410}
411
412static inline vcl_session_handle_t
Florin Coras134a9962018-08-28 11:32:04 -0700413vcl_session_handle (vcl_session_t * s)
Florin Coras54693d22018-07-17 10:46:29 -0700414{
Florin Corasf9240dc2019-01-15 08:03:17 -0800415 return vcl_session_handle_from_index (s->session_index);
Florin Coras134a9962018-08-28 11:32:04 -0700416}
417
418static inline void
419vcl_session_handle_parse (u32 handle, u32 * wrk_index, u32 * session_index)
420{
421 *wrk_index = handle >> 24;
422 *session_index = handle & 0xFFFFFF;
Florin Coras54693d22018-07-17 10:46:29 -0700423}
424
425static inline vcl_session_t *
Florin Coras134a9962018-08-28 11:32:04 -0700426vcl_session_get_w_handle (vcl_worker_t * wrk, u32 session_handle)
427{
428 u32 session_index, wrk_index;
429 vcl_session_handle_parse (session_handle, &wrk_index, &session_index);
430 ASSERT (wrk_index == wrk->wrk_index);
431 return vcl_session_get (wrk, session_index);
432}
433
434static inline vcl_session_t *
435vcl_session_get_w_vpp_handle (vcl_worker_t * wrk, u64 vpp_handle)
Florin Coras54693d22018-07-17 10:46:29 -0700436{
437 uword *p;
Florin Coras134a9962018-08-28 11:32:04 -0700438 if ((p = hash_get (wrk->session_index_by_vpp_handles, vpp_handle)))
439 return vcl_session_get (wrk, (u32) p[0]);
Florin Coras54693d22018-07-17 10:46:29 -0700440 return 0;
441}
442
443static inline u32
Florin Coras134a9962018-08-28 11:32:04 -0700444vcl_session_index_from_vpp_handle (vcl_worker_t * wrk, u64 vpp_handle)
Florin Coras54693d22018-07-17 10:46:29 -0700445{
446 uword *p;
Florin Coras134a9962018-08-28 11:32:04 -0700447 if ((p = hash_get (wrk->session_index_by_vpp_handles, vpp_handle)))
Florin Coras54693d22018-07-17 10:46:29 -0700448 return p[0];
449 return VCL_INVALID_SESSION_INDEX;
450}
451
Florin Coras134a9962018-08-28 11:32:04 -0700452static inline void
453vcl_session_table_add_vpp_handle (vcl_worker_t * wrk, u64 handle, u32 value)
454{
455 hash_set (wrk->session_index_by_vpp_handles, handle, value);
456}
457
458static inline void
459vcl_session_table_del_vpp_handle (vcl_worker_t * wrk, u64 vpp_handle)
460{
461 hash_unset (wrk->session_index_by_vpp_handles, vpp_handle);
462}
463
464static inline uword *
465vcl_session_table_lookup_vpp_handle (vcl_worker_t * wrk, u64 handle)
466{
467 return hash_get (wrk->session_index_by_vpp_handles, handle);
468}
469
470static inline void
471vcl_session_table_add_listener (vcl_worker_t * wrk, u64 listener_handle,
472 u32 value)
473{
Florin Coras134a9962018-08-28 11:32:04 -0700474 hash_set (wrk->session_index_by_vpp_handles, listener_handle, value);
475}
476
477static inline void
478vcl_session_table_del_listener (vcl_worker_t * wrk, u64 listener_handle)
479{
Florin Coras134a9962018-08-28 11:32:04 -0700480 hash_unset (wrk->session_index_by_vpp_handles, listener_handle);
481}
482
Nathan Skrzypczak9fd99622019-05-16 14:38:44 +0200483static inline int
484vcl_session_is_connectable_listener (vcl_worker_t * wrk,
485 vcl_session_t * session)
486{
487 /* Tell if we session_handle is a QUIC session.
488 * We can be in the following cases :
489 * Listen session <- QUIC session <- Stream session
490 * QUIC session <- Stream session
491 */
492 vcl_session_t *ls;
493 if (session->session_type != VPPCOM_PROTO_QUIC)
494 return 0;
495 if (session->listener_index == VCL_INVALID_SESSION_INDEX)
Florin Corasc127d5a2020-10-14 16:35:58 -0700496 return !(session->session_state == VCL_STATE_LISTEN);
Nathan Skrzypczak9fd99622019-05-16 14:38:44 +0200497 ls = vcl_session_get_w_handle (wrk, session->listener_index);
498 if (!ls)
499 return VPPCOM_EBADFD;
Florin Corasc127d5a2020-10-14 16:35:58 -0700500 return ls->session_state == VCL_STATE_LISTEN;
Nathan Skrzypczak9fd99622019-05-16 14:38:44 +0200501}
502
Florin Coras134a9962018-08-28 11:32:04 -0700503static inline vcl_session_t *
Florin Corasdfae9f92019-02-20 19:48:31 -0800504vcl_session_table_lookup_listener (vcl_worker_t * wrk, u64 handle)
Florin Coras134a9962018-08-28 11:32:04 -0700505{
506 uword *p;
Florin Corasc127d5a2020-10-14 16:35:58 -0700507 vcl_session_t *s;
Florin Coras134a9962018-08-28 11:32:04 -0700508
509 p = hash_get (wrk->session_index_by_vpp_handles, handle);
510 if (!p)
511 {
Florin Corasdfae9f92019-02-20 19:48:31 -0800512 VDBG (0, "could not find listen session: unknown vpp listener handle"
513 " %llx", handle);
Florin Coras134a9962018-08-28 11:32:04 -0700514 return 0;
515 }
Florin Corasc127d5a2020-10-14 16:35:58 -0700516 s = vcl_session_get (wrk, p[0]);
517 if (!s)
Florin Coras134a9962018-08-28 11:32:04 -0700518 {
Florin Corasdfae9f92019-02-20 19:48:31 -0800519 VDBG (1, "invalid listen session index (%u)", p[0]);
Florin Coras134a9962018-08-28 11:32:04 -0700520 return 0;
521 }
522
Florin Corasc127d5a2020-10-14 16:35:58 -0700523 ASSERT (s->session_state == VCL_STATE_LISTEN
524 || s->session_state == VCL_STATE_LISTEN_NO_MQ
525 || vcl_session_is_connectable_listener (wrk, s));
526 return s;
Florin Coras134a9962018-08-28 11:32:04 -0700527}
528
Florin Coras288eaab2019-02-03 15:26:14 -0800529const char *vppcom_session_state_str (vcl_session_state_t state);
Florin Coras134a9962018-08-28 11:32:04 -0700530
Florin Coras460dce62018-07-27 05:45:06 -0700531static inline u8
532vcl_session_is_ct (vcl_session_t * s)
533{
Florin Coras653e43f2019-03-04 10:56:23 -0800534 return (s->ct_tx_fifo != 0);
Florin Coras460dce62018-07-27 05:45:06 -0700535}
536
Florin Coras6d0106e2019-01-29 20:11:58 -0800537static inline u8
Florin Coras6e3c1f82020-01-15 01:30:46 +0000538vcl_session_is_cl (vcl_session_t * s)
539{
540 if (s->session_type == VPPCOM_PROTO_UDP)
Florin Corasa4dac8a2020-05-25 18:17:03 +0000541 return !(s->flags & VCL_SESSION_F_CONNECTED);
Florin Coras6e3c1f82020-01-15 01:30:46 +0000542 return 0;
543}
544
545static inline u8
Florin Corasa5a9efd2021-01-05 17:03:29 -0800546vcl_session_has_crypto (vcl_session_t *s)
547{
548 return (s->session_type == VPPCOM_PROTO_TLS ||
Florin Coras4b47ee22020-11-19 13:38:26 -0800549 s->session_type == VPPCOM_PROTO_QUIC ||
550 s->session_type == VPPCOM_PROTO_DTLS);
Florin Corasa5a9efd2021-01-05 17:03:29 -0800551}
552
553static inline u8
Florin Corasc127d5a2020-10-14 16:35:58 -0700554vcl_session_is_ready (vcl_session_t * s)
555{
Florin Corasdfffdd72020-10-15 10:54:47 -0700556 return (s->session_state == VCL_STATE_READY
Florin Corasc127d5a2020-10-14 16:35:58 -0700557 || s->session_state == VCL_STATE_VPP_CLOSING);
558}
559
560static inline u8
Florin Coras6d0106e2019-01-29 20:11:58 -0800561vcl_session_is_open (vcl_session_t * s)
562{
Florin Corasc127d5a2020-10-14 16:35:58 -0700563 return ((vcl_session_is_ready (s))
Florin Coras1bc919e2020-10-18 20:17:49 -0700564 || (s->session_state == VCL_STATE_LISTEN && vcl_session_is_cl (s)));
Florin Coras6d0106e2019-01-29 20:11:58 -0800565}
566
567static inline u8
568vcl_session_is_closing (vcl_session_t * s)
569{
Florin Corasc127d5a2020-10-14 16:35:58 -0700570 return (s->session_state == VCL_STATE_VPP_CLOSING
571 || s->session_state == VCL_STATE_DISCONNECT);
Florin Coras6d0106e2019-01-29 20:11:58 -0800572}
573
Florin Coras080aa502020-05-26 00:47:52 +0000574static inline u8
575vcl_session_is_closed (vcl_session_t * s)
576{
Florin Corasc127d5a2020-10-14 16:35:58 -0700577 return (!s || (s->session_state == VCL_STATE_CLOSED));
Florin Coras080aa502020-05-26 00:47:52 +0000578}
579
Florin Coras6d0106e2019-01-29 20:11:58 -0800580static inline int
581vcl_session_closing_error (vcl_session_t * s)
582{
Florin Coras067f9542020-02-14 05:33:46 +0000583 /* Return 0 on closing sockets */
Florin Corasc127d5a2020-10-14 16:35:58 -0700584 return s->session_state == VCL_STATE_DISCONNECT ? VPPCOM_ECONNRESET : 0;
Florin Coras6d0106e2019-01-29 20:11:58 -0800585}
586
587static inline int
588vcl_session_closed_error (vcl_session_t * s)
589{
Florin Corasc127d5a2020-10-14 16:35:58 -0700590 return s->session_state == VCL_STATE_DISCONNECT
Florin Coras6d0106e2019-01-29 20:11:58 -0800591 ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN;
592}
593
Florin Coras5da10c42020-04-01 04:31:21 +0000594static inline void
595vcl_ip_copy_from_ep (ip46_address_t * ip, vppcom_endpt_t * ep)
596{
597 if (ep->is_ip4)
598 clib_memcpy_fast (&ip->ip4, ep->ip, sizeof (ip4_address_t));
599 else
600 clib_memcpy_fast (&ip->ip6, ep->ip, sizeof (ip6_address_t));
601}
602
603static inline void
604vcl_ip_copy_to_ep (ip46_address_t * ip, vppcom_endpt_t * ep, u8 is_ip4)
605{
606 ep->is_ip4 = is_ip4;
607 if (is_ip4)
608 clib_memcpy_fast (ep->ip, &ip->ip4, sizeof (ip4_address_t));
609 else
610 clib_memcpy_fast (ep->ip, &ip->ip6, sizeof (ip6_address_t));
611}
612
Florin Coras66ec4672020-06-15 07:59:40 -0700613static inline int
614vcl_proto_is_dgram (uint8_t proto)
615{
Florin Coras4b47ee22020-11-19 13:38:26 -0800616 return proto == VPPCOM_PROTO_UDP || proto == VPPCOM_PROTO_DTLS;
Florin Coras66ec4672020-06-15 07:59:40 -0700617}
618
Florin Corasac422d62020-10-19 20:51:36 -0700619static inline u8
620vcl_session_has_attr (vcl_session_t * s, u8 attr)
621{
622 return (s->attributes & (1 << attr)) ? 1 : 0;
623}
624
625static inline void
626vcl_session_set_attr (vcl_session_t * s, u8 attr)
627{
628 s->attributes |= 1 << attr;
629}
630
631static inline void
632vcl_session_clear_attr (vcl_session_t * s, u8 attr)
633{
634 s->attributes &= ~(1 << attr);
635}
636
Florin Coras697faea2018-06-27 17:10:49 -0700637/*
Florin Coras99368312018-08-02 10:45:44 -0700638 * Helpers
639 */
Florin Coras134a9962018-08-28 11:32:04 -0700640vcl_mq_evt_conn_t *vcl_mq_evt_conn_alloc (vcl_worker_t * wrk);
641u32 vcl_mq_evt_conn_index (vcl_worker_t * wrk, vcl_mq_evt_conn_t * mqc);
642vcl_mq_evt_conn_t *vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx);
643int vcl_mq_epoll_add_evfd (vcl_worker_t * wrk, svm_msg_q_t * mq);
644int vcl_mq_epoll_del_evfd (vcl_worker_t * wrk, u32 mqc_index);
645
646vcl_worker_t *vcl_worker_alloc_and_init (void);
Florin Coras01f3f892018-12-02 12:45:53 -0800647void vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp);
Florin Coras47c40e22018-11-26 17:01:36 -0800648int vcl_worker_register_with_vpp (void);
Florin Coras458089b2019-08-21 16:20:44 -0700649svm_msg_q_t *vcl_worker_ctrl_mq (vcl_worker_t * wrk);
Florin Corasf9240dc2019-01-15 08:03:17 -0800650
651void vcl_flush_mq_events (void);
Florin Corasf9240dc2019-01-15 08:03:17 -0800652int vcl_session_cleanup (vcl_worker_t * wrk, vcl_session_t * session,
653 vcl_session_handle_t sh, u8 do_disconnect);
Florin Coras134a9962018-08-28 11:32:04 -0700654
Florin Corasd85de682018-11-29 17:02:29 -0800655void vcl_segment_table_add (u64 segment_handle, u32 svm_segment_index);
656u32 vcl_segment_table_lookup (u64 segment_handle);
657void vcl_segment_table_del (u64 segment_handle);
658
Florin Coras0ef8ef22019-01-18 08:37:13 -0800659int vcl_session_read_ready (vcl_session_t * session);
660int vcl_session_write_ready (vcl_session_t * session);
661
Florin Coras134a9962018-08-28 11:32:04 -0700662static inline vcl_worker_t *
663vcl_worker_get (u32 wrk_index)
664{
665 return pool_elt_at_index (vcm->workers, wrk_index);
666}
667
668static inline vcl_worker_t *
Florin Coras01f3f892018-12-02 12:45:53 -0800669vcl_worker_get_if_valid (u32 wrk_index)
670{
671 if (pool_is_free_index (vcm->workers, wrk_index))
672 return 0;
673 return pool_elt_at_index (vcm->workers, wrk_index);
674}
675
676static inline vcl_worker_t *
Florin Coras134a9962018-08-28 11:32:04 -0700677vcl_worker_get_current (void)
678{
679 return vcl_worker_get (vcl_get_worker_index ());
680}
Florin Coras99368312018-08-02 10:45:44 -0700681
Florin Coras2d675d72019-01-28 15:54:27 -0800682static inline u8
683vcl_n_workers (void)
684{
685 return pool_elts (vcm->workers);
686}
687
Florin Coras935ce752020-09-08 22:43:47 -0700688static inline u64
689vcl_vpp_worker_segment_handle (u32 wrk_index)
690{
691 return (VCL_INVALID_SEGMENT_HANDLE - wrk_index - 1);
692}
693
Florin Coras30e79c22019-01-02 19:31:22 -0800694void vcl_send_session_worker_update (vcl_worker_t * wrk, vcl_session_t * s,
695 u32 wrk_index);
hanlina3a48962020-07-13 11:09:15 +0800696int vcl_send_worker_rpc (u32 dst_wrk_index, void *data, u32 data_len);
Florin Coras40c07ce2020-07-16 20:46:17 -0700697
Florin Corasc4c4cf52019-08-24 18:17:34 -0700698int vcl_segment_attach (u64 segment_handle, char *name,
699 ssvm_segment_type_t type, int fd);
700void vcl_segment_detach (u64 segment_handle);
Florin Corasb88de902020-09-08 16:47:57 -0700701void vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s);
Florin Corasc4c4cf52019-08-24 18:17:34 -0700702
Florin Corasc547e912020-12-08 17:50:45 -0800703int vcl_segment_attach_session (uword segment_handle, uword rxf_offset,
Florin Corasb4624182020-12-11 13:58:12 -0800704 uword txf_offset, uword mq_offset, u8 is_ct,
705 vcl_session_t *s);
706int vcl_segment_attach_mq (uword segment_handle, uword mq_offset, u32 mq_index,
707 svm_msg_q_t **mq);
Florin Coras80b74252021-01-27 18:08:25 -0800708int vcl_segment_discover_mqs (uword segment_handle, int *fds, u32 n_fds);
Florin Corasc547e912020-12-08 17:50:45 -0800709
Florin Corasb88de902020-09-08 16:47:57 -0700710/*
711 * VCL Binary API
712 */
713int vcl_bapi_attach (void);
714int vcl_bapi_app_worker_add (void);
715void vcl_bapi_app_worker_del (vcl_worker_t * wrk);
716void vcl_bapi_disconnect_from_vpp (void);
Florin Coras935ce752020-09-08 22:43:47 -0700717int vcl_bapi_recv_fds (vcl_worker_t * wrk, int *fds, int n_fds);
Florin Corasa5a9efd2021-01-05 17:03:29 -0800718int vcl_bapi_add_cert_key_pair (vppcom_cert_key_pair_t *ckpair);
719int vcl_bapi_del_cert_key_pair (u32 ckpair_index);
Florin Corasb88de902020-09-08 16:47:57 -0700720u32 vcl_bapi_max_nsid_len (void);
721int vcl_bapi_worker_set (void);
Florin Coras697faea2018-06-27 17:10:49 -0700722
Florin Coras935ce752020-09-08 22:43:47 -0700723/*
724 * VCL Socket API
725 */
726int vcl_sapi_attach (void);
727int vcl_sapi_app_worker_add (void);
728void vcl_sapi_app_worker_del (vcl_worker_t * wrk);
729void vcl_sapi_detach (vcl_worker_t * wrk);
730int vcl_sapi_recv_fds (vcl_worker_t * wrk, int *fds, int n_fds);
731
Florin Coras697faea2018-06-27 17:10:49 -0700732#endif /* SRC_VCL_VCL_PRIVATE_H_ */
733
734/*
735 * fd.io coding-style-patch-verification: ON
736 *
737 * Local Variables:
738 * eval: (c-set-style "gnu")
739 * End:
740 */