blob: 773350ae0c999c5f255005096af9529a6be49d77 [file] [log] [blame]
Dave Wallace543852a2017-08-03 02:11:34 -04001/*
Dave Wallace33e002b2017-09-06 01:20:02 -04002 * Copyright (c) 2017 Cisco and/or its affiliates.
Dave Wallace543852a2017-08-03 02:11:34 -04003 * 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#include <stdio.h>
17#include <stdlib.h>
Dave Wallace543852a2017-08-03 02:11:34 -040018#include <svm/svm_fifo_segment.h>
Dave Wallace5c7cf1c2017-10-24 04:12:18 -040019#include <vcl/vppcom.h>
Florin Coras0d427d82018-06-27 03:24:07 -070020#include <vcl/vcl_debug.h>
Florin Coras697faea2018-06-27 17:10:49 -070021#include <vcl/vcl_private.h>
Dave Wallace7e607a72018-06-18 18:41:32 -040022
Florin Coras134a9962018-08-28 11:32:04 -070023__thread uword __vcl_worker_index = ~0;
24
Florin Coras54693d22018-07-17 10:46:29 -070025
Florin Corasd85de682018-11-29 17:02:29 -080026static int
27vcl_wait_for_segment (u64 segment_handle)
Florin Coras54693d22018-07-17 10:46:29 -070028{
Florin Corasd85de682018-11-29 17:02:29 -080029 vcl_worker_t *wrk = vcl_worker_get_current ();
30 u32 wait_for_seconds = 10, segment_index;
31 f64 timeout;
Florin Coras54693d22018-07-17 10:46:29 -070032
Florin Corasd85de682018-11-29 17:02:29 -080033 if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
34 return 1;
Florin Coras54693d22018-07-17 10:46:29 -070035
Florin Corasd85de682018-11-29 17:02:29 -080036 timeout = clib_time_now (&wrk->clib_time) + wait_for_seconds;
37 while (clib_time_now (&wrk->clib_time) < timeout)
Florin Coras54693d22018-07-17 10:46:29 -070038 {
Florin Corasd85de682018-11-29 17:02:29 -080039 segment_index = vcl_segment_table_lookup (segment_handle);
40 if (segment_index != VCL_INVALID_SEGMENT_INDEX)
41 return 0;
42 usleep (10);
Florin Coras54693d22018-07-17 10:46:29 -070043 }
Florin Corasd85de682018-11-29 17:02:29 -080044 return 1;
Florin Coras54693d22018-07-17 10:46:29 -070045}
46
Florin Coras697faea2018-06-27 17:10:49 -070047const char *
Dave Wallace543852a2017-08-03 02:11:34 -040048vppcom_session_state_str (session_state_t state)
49{
50 char *st;
51
52 switch (state)
53 {
54 case STATE_START:
55 st = "STATE_START";
56 break;
57
58 case STATE_CONNECT:
59 st = "STATE_CONNECT";
60 break;
61
62 case STATE_LISTEN:
63 st = "STATE_LISTEN";
64 break;
65
66 case STATE_ACCEPT:
67 st = "STATE_ACCEPT";
68 break;
69
Florin Coras3c7d4f92018-12-14 11:28:43 -080070 case STATE_VPP_CLOSING:
71 st = "STATE_VPP_CLOSING";
Dave Wallace4878cbe2017-11-21 03:45:09 -050072 break;
73
Dave Wallace543852a2017-08-03 02:11:34 -040074 case STATE_DISCONNECT:
75 st = "STATE_DISCONNECT";
76 break;
77
78 case STATE_FAILED:
79 st = "STATE_FAILED";
80 break;
81
82 default:
83 st = "UNKNOWN_STATE";
84 break;
85 }
86
87 return st;
88}
89
Dave Wallace543852a2017-08-03 02:11:34 -040090u8 *
91format_ip4_address (u8 * s, va_list * args)
92{
93 u8 *a = va_arg (*args, u8 *);
94 return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
95}
96
97u8 *
98format_ip6_address (u8 * s, va_list * args)
99{
100 ip6_address_t *a = va_arg (*args, ip6_address_t *);
101 u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
102
103 i_max_n_zero = ARRAY_LEN (a->as_u16);
104 max_n_zeros = 0;
105 i_first_zero = i_max_n_zero;
106 n_zeros = 0;
107 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
108 {
109 u32 is_zero = a->as_u16[i] == 0;
110 if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
111 {
112 i_first_zero = i;
113 n_zeros = 0;
114 }
115 n_zeros += is_zero;
116 if ((!is_zero && n_zeros > max_n_zeros)
117 || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
118 {
119 i_max_n_zero = i_first_zero;
120 max_n_zeros = n_zeros;
121 i_first_zero = ARRAY_LEN (a->as_u16);
122 n_zeros = 0;
123 }
124 }
125
126 last_double_colon = 0;
127 for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
128 {
129 if (i == i_max_n_zero && max_n_zeros > 1)
130 {
131 s = format (s, "::");
132 i += max_n_zeros - 1;
133 last_double_colon = 1;
134 }
135 else
136 {
137 s = format (s, "%s%x",
138 (last_double_colon || i == 0) ? "" : ":",
139 clib_net_to_host_u16 (a->as_u16[i]));
140 last_double_colon = 0;
141 }
142 }
143
144 return s;
145}
146
147/* Format an IP46 address. */
148u8 *
149format_ip46_address (u8 * s, va_list * args)
150{
151 ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
152 ip46_type_t type = va_arg (*args, ip46_type_t);
153 int is_ip4 = 1;
154
155 switch (type)
156 {
157 case IP46_TYPE_ANY:
158 is_ip4 = ip46_address_is_ip4 (ip46);
159 break;
160 case IP46_TYPE_IP4:
161 is_ip4 = 1;
162 break;
163 case IP46_TYPE_IP6:
164 is_ip4 = 0;
165 break;
166 }
167
168 return is_ip4 ?
169 format (s, "%U", format_ip4_address, &ip46->ip4) :
170 format (s, "%U", format_ip6_address, &ip46->ip6);
171}
172
Florin Coras697faea2018-06-27 17:10:49 -0700173/*
174 * VPPCOM Utility Functions
175 */
176
Florin Coras697faea2018-06-27 17:10:49 -0700177
Florin Corasc9fbd662018-08-24 12:59:56 -0700178static svm_msg_q_t *
Florin Coras134a9962018-08-28 11:32:04 -0700179vcl_session_vpp_evt_q (vcl_worker_t * wrk, vcl_session_t * s)
Florin Corasc9fbd662018-08-24 12:59:56 -0700180{
181 if (vcl_session_is_ct (s))
Florin Coras134a9962018-08-28 11:32:04 -0700182 return wrk->vpp_event_queues[0];
Florin Corasc9fbd662018-08-24 12:59:56 -0700183 else
Florin Coras3c7d4f92018-12-14 11:28:43 -0800184 return wrk->vpp_event_queues[s->vpp_thread_index];
Florin Corasc9fbd662018-08-24 12:59:56 -0700185}
186
Florin Coras54693d22018-07-17 10:46:29 -0700187static void
188vcl_send_session_accepted_reply (svm_msg_q_t * mq, u32 context,
189 session_handle_t handle, int retval)
190{
191 app_session_evt_t _app_evt, *app_evt = &_app_evt;
192 session_accepted_reply_msg_t *rmp;
193 app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_ACCEPTED_REPLY);
194 rmp = (session_accepted_reply_msg_t *) app_evt->evt->data;
195 rmp->handle = handle;
196 rmp->context = context;
197 rmp->retval = retval;
198 app_send_ctrl_evt_to_vpp (mq, app_evt);
199}
200
Florin Coras99368312018-08-02 10:45:44 -0700201static void
202vcl_send_session_disconnected_reply (svm_msg_q_t * mq, u32 context,
203 session_handle_t handle, int retval)
204{
205 app_session_evt_t _app_evt, *app_evt = &_app_evt;
206 session_disconnected_reply_msg_t *rmp;
207 app_alloc_ctrl_evt_to_vpp (mq, app_evt,
208 SESSION_CTRL_EVT_DISCONNECTED_REPLY);
209 rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
210 rmp->handle = handle;
211 rmp->context = context;
212 rmp->retval = retval;
213 app_send_ctrl_evt_to_vpp (mq, app_evt);
214}
215
Florin Corasc9fbd662018-08-24 12:59:56 -0700216static void
217vcl_send_session_reset_reply (svm_msg_q_t * mq, u32 context,
218 session_handle_t handle, int retval)
219{
220 app_session_evt_t _app_evt, *app_evt = &_app_evt;
221 session_reset_reply_msg_t *rmp;
222 app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_RESET_REPLY);
223 rmp = (session_reset_reply_msg_t *) app_evt->evt->data;
224 rmp->handle = handle;
225 rmp->context = context;
226 rmp->retval = retval;
227 app_send_ctrl_evt_to_vpp (mq, app_evt);
228}
229
Florin Coras54693d22018-07-17 10:46:29 -0700230static u32
Florin Coras134a9962018-08-28 11:32:04 -0700231vcl_session_accepted_handler (vcl_worker_t * wrk, session_accepted_msg_t * mp)
Florin Coras54693d22018-07-17 10:46:29 -0700232{
233 vcl_session_t *session, *listen_session;
234 svm_fifo_t *rx_fifo, *tx_fifo;
Florin Coras134a9962018-08-28 11:32:04 -0700235 u32 vpp_wrk_index;
Florin Coras99368312018-08-02 10:45:44 -0700236 svm_msg_q_t *evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700237
Florin Coras134a9962018-08-28 11:32:04 -0700238 session = vcl_session_alloc (wrk);
Florin Coras99368312018-08-02 10:45:44 -0700239
Florin Coras134a9962018-08-28 11:32:04 -0700240 listen_session = vcl_session_table_lookup_listener (wrk,
241 mp->listener_handle);
Florin Coras54693d22018-07-17 10:46:29 -0700242 if (!listen_session)
243 {
244 svm_msg_q_t *evt_q;
245 evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
246 clib_warning ("VCL<%d>: ERROR: couldn't find listen session: "
247 "unknown vpp listener handle %llx",
248 getpid (), mp->listener_handle);
249 vcl_send_session_accepted_reply (evt_q, mp->context, mp->handle,
250 VNET_API_ERROR_INVALID_ARGUMENT);
Florin Coras134a9962018-08-28 11:32:04 -0700251 vcl_session_free (wrk, session);
Florin Coras54693d22018-07-17 10:46:29 -0700252 return VCL_INVALID_SESSION_INDEX;
253 }
254
Florin Coras54693d22018-07-17 10:46:29 -0700255 rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
256 tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
257
258 if (mp->server_event_queue_address)
259 {
260 session->vpp_evt_q = uword_to_pointer (mp->client_event_queue_address,
261 svm_msg_q_t *);
262 session->our_evt_q = uword_to_pointer (mp->server_event_queue_address,
263 svm_msg_q_t *);
Florin Corasd85de682018-11-29 17:02:29 -0800264 if (vcl_wait_for_segment (mp->segment_handle))
265 {
266 clib_warning ("segment for session %u couldn't be mounted!",
267 session->session_index);
268 return VCL_INVALID_SESSION_INDEX;
269 }
Florin Coras134a9962018-08-28 11:32:04 -0700270 rx_fifo->master_session_index = session->session_index;
271 tx_fifo->master_session_index = session->session_index;
Florin Coras21795132018-09-09 09:40:51 -0700272 rx_fifo->master_thread_index = vcl_get_worker_index ();
273 tx_fifo->master_thread_index = vcl_get_worker_index ();
Florin Coras134a9962018-08-28 11:32:04 -0700274 vec_validate (wrk->vpp_event_queues, 0);
Florin Coras99368312018-08-02 10:45:44 -0700275 evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
Florin Coras134a9962018-08-28 11:32:04 -0700276 wrk->vpp_event_queues[0] = evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700277 }
278 else
279 {
280 session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
281 svm_msg_q_t *);
Florin Coras134a9962018-08-28 11:32:04 -0700282 rx_fifo->client_session_index = session->session_index;
283 tx_fifo->client_session_index = session->session_index;
Florin Coras21795132018-09-09 09:40:51 -0700284 rx_fifo->client_thread_index = vcl_get_worker_index ();
285 tx_fifo->client_thread_index = vcl_get_worker_index ();
Florin Coras99368312018-08-02 10:45:44 -0700286 vpp_wrk_index = tx_fifo->master_thread_index;
Florin Coras134a9962018-08-28 11:32:04 -0700287 vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
288 wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700289 }
290
291 session->vpp_handle = mp->handle;
Florin Coras3c7d4f92018-12-14 11:28:43 -0800292 session->vpp_thread_index = rx_fifo->master_thread_index;
Florin Coras54693d22018-07-17 10:46:29 -0700293 session->client_context = mp->context;
294 session->rx_fifo = rx_fifo;
295 session->tx_fifo = tx_fifo;
296
297 session->session_state = STATE_ACCEPT;
298 session->transport.rmt_port = mp->port;
299 session->transport.is_ip4 = mp->is_ip4;
Dave Barach178cf492018-11-13 16:34:13 -0500300 clib_memcpy_fast (&session->transport.rmt_ip, mp->ip,
301 sizeof (ip46_address_t));
Florin Coras54693d22018-07-17 10:46:29 -0700302
Florin Coras134a9962018-08-28 11:32:04 -0700303 vcl_session_table_add_vpp_handle (wrk, mp->handle, session->session_index);
Florin Coras54693d22018-07-17 10:46:29 -0700304 session->transport.lcl_port = listen_session->transport.lcl_port;
305 session->transport.lcl_ip = listen_session->transport.lcl_ip;
Florin Coras460dce62018-07-27 05:45:06 -0700306 session->session_type = listen_session->session_type;
307 session->is_dgram = session->session_type == VPPCOM_PROTO_UDP;
Florin Coras54693d22018-07-17 10:46:29 -0700308
309 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: client accept request from %s"
Florin Coras134a9962018-08-28 11:32:04 -0700310 " address %U port %d queue %p!", getpid (), mp->handle,
311 session->session_index,
Florin Coras54693d22018-07-17 10:46:29 -0700312 mp->is_ip4 ? "IPv4" : "IPv6", format_ip46_address, &mp->ip,
313 mp->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
314 clib_net_to_host_u16 (mp->port), session->vpp_evt_q);
315 vcl_evt (VCL_EVT_ACCEPT, session, listen_session, session_index);
316
Florin Coras134a9962018-08-28 11:32:04 -0700317 return session->session_index;
Florin Coras54693d22018-07-17 10:46:29 -0700318}
319
320static u32
Florin Coras134a9962018-08-28 11:32:04 -0700321vcl_session_connected_handler (vcl_worker_t * wrk,
322 session_connected_msg_t * mp)
Florin Coras54693d22018-07-17 10:46:29 -0700323{
Florin Coras99368312018-08-02 10:45:44 -0700324 u32 session_index, vpp_wrk_index;
Florin Coras54693d22018-07-17 10:46:29 -0700325 svm_fifo_t *rx_fifo, *tx_fifo;
Florin Coras99368312018-08-02 10:45:44 -0700326 vcl_session_t *session = 0;
327 svm_msg_q_t *evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700328
329 session_index = mp->context;
Florin Coras134a9962018-08-28 11:32:04 -0700330 session = vcl_session_get (wrk, session_index);
Florin Coras070453d2018-08-24 17:04:27 -0700331 if (!session)
332 {
333 clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
334 "Invalid session index (%u)!",
335 getpid (), mp->handle, session_index);
336 return VCL_INVALID_SESSION_INDEX;
337 }
Florin Coras54693d22018-07-17 10:46:29 -0700338 if (mp->retval)
339 {
Florin Coras070453d2018-08-24 17:04:27 -0700340 clib_warning ("VCL<%d>: ERROR: sid %u: connect failed! %U", getpid (),
Florin Coras21795132018-09-09 09:40:51 -0700341 session_index, format_api_error, ntohl (mp->retval));
Florin Coras070453d2018-08-24 17:04:27 -0700342 session->session_state = STATE_FAILED;
343 session->vpp_handle = mp->handle;
344 return session_index;
Florin Coras54693d22018-07-17 10:46:29 -0700345 }
346
Florin Coras460dce62018-07-27 05:45:06 -0700347 rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
348 tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
Florin Corasd85de682018-11-29 17:02:29 -0800349 if (vcl_wait_for_segment (mp->segment_handle))
350 {
351 clib_warning ("segment for session %u couldn't be mounted!",
352 session->session_index);
353 return VCL_INVALID_SESSION_INDEX;
354 }
355
Florin Coras460dce62018-07-27 05:45:06 -0700356 rx_fifo->client_session_index = session_index;
357 tx_fifo->client_session_index = session_index;
Florin Coras21795132018-09-09 09:40:51 -0700358 rx_fifo->client_thread_index = vcl_get_worker_index ();
359 tx_fifo->client_thread_index = vcl_get_worker_index ();
Florin Coras460dce62018-07-27 05:45:06 -0700360
Florin Coras54693d22018-07-17 10:46:29 -0700361 if (mp->client_event_queue_address)
362 {
363 session->vpp_evt_q = uword_to_pointer (mp->server_event_queue_address,
364 svm_msg_q_t *);
365 session->our_evt_q = uword_to_pointer (mp->client_event_queue_address,
366 svm_msg_q_t *);
Florin Coras99368312018-08-02 10:45:44 -0700367
Florin Coras134a9962018-08-28 11:32:04 -0700368 vec_validate (wrk->vpp_event_queues, 0);
Florin Coras99368312018-08-02 10:45:44 -0700369 evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
Florin Coras134a9962018-08-28 11:32:04 -0700370 wrk->vpp_event_queues[0] = evt_q;
Florin Coras54693d22018-07-17 10:46:29 -0700371 }
372 else
Florin Coras99368312018-08-02 10:45:44 -0700373 {
374 session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
375 svm_msg_q_t *);
376 vpp_wrk_index = tx_fifo->master_thread_index;
Florin Coras134a9962018-08-28 11:32:04 -0700377 vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
378 wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
Florin Coras99368312018-08-02 10:45:44 -0700379 }
Florin Coras54693d22018-07-17 10:46:29 -0700380
Florin Coras54693d22018-07-17 10:46:29 -0700381 session->rx_fifo = rx_fifo;
382 session->tx_fifo = tx_fifo;
383 session->vpp_handle = mp->handle;
Florin Coras3c7d4f92018-12-14 11:28:43 -0800384 session->vpp_thread_index = rx_fifo->master_thread_index;
Florin Coras54693d22018-07-17 10:46:29 -0700385 session->transport.is_ip4 = mp->is_ip4;
Dave Barach178cf492018-11-13 16:34:13 -0500386 clib_memcpy_fast (&session->transport.lcl_ip, mp->lcl_ip,
387 sizeof (session->transport.lcl_ip));
Florin Coras54693d22018-07-17 10:46:29 -0700388 session->transport.lcl_port = mp->lcl_port;
389 session->session_state = STATE_CONNECT;
390
391 /* Add it to lookup table */
Florin Coras3c7d4f92018-12-14 11:28:43 -0800392 vcl_session_table_add_vpp_handle (wrk, mp->handle, session_index);
Florin Coras54693d22018-07-17 10:46:29 -0700393
394 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: connect succeeded! "
395 "session_rx_fifo %p, refcnt %d, session_tx_fifo %p, refcnt %d",
396 getpid (), mp->handle, session_index, session->rx_fifo,
397 session->rx_fifo->refcnt, session->tx_fifo, session->tx_fifo->refcnt);
Florin Coras070453d2018-08-24 17:04:27 -0700398
Florin Coras54693d22018-07-17 10:46:29 -0700399 return session_index;
400}
401
Florin Coras3c7d4f92018-12-14 11:28:43 -0800402static int
403vcl_flag_accepted_session (vcl_session_t * session, u64 handle, u32 flags)
404{
405 vcl_session_msg_t *accepted_msg;
406 int i;
407
408 for (i = 0; i < vec_len (session->accept_evts_fifo); i++)
409 {
410 accepted_msg = &session->accept_evts_fifo[i];
411 if (accepted_msg->accepted_msg.handle == handle)
412 {
413 accepted_msg->flags = flags;
414 return 1;
415 }
416 }
417 return 0;
418}
419
Florin Corasc9fbd662018-08-24 12:59:56 -0700420static u32
Florin Coras134a9962018-08-28 11:32:04 -0700421vcl_session_reset_handler (vcl_worker_t * wrk,
422 session_reset_msg_t * reset_msg)
Florin Corasc9fbd662018-08-24 12:59:56 -0700423{
424 vcl_session_t *session;
425 u32 sid;
426
Florin Coras134a9962018-08-28 11:32:04 -0700427 sid = vcl_session_index_from_vpp_handle (wrk, reset_msg->handle);
428 session = vcl_session_get (wrk, sid);
Florin Corasc9fbd662018-08-24 12:59:56 -0700429 if (!session)
430 {
431 VDBG (0, "request to reset unknown handle 0x%llx", reset_msg->handle);
432 return VCL_INVALID_SESSION_INDEX;
433 }
Florin Coras3c7d4f92018-12-14 11:28:43 -0800434 if (session->session_state >= STATE_VPP_CLOSING)
435 return sid;
436
437 /* Caught a reset before actually accepting the session */
438 if (session->session_state == STATE_LISTEN)
439 {
440
441 if (!vcl_flag_accepted_session (session, reset_msg->handle,
442 VCL_ACCEPTED_F_RESET))
443 VDBG (0, "session was not accepted!");
444 return VCL_INVALID_SESSION_INDEX;
445 }
446
447 session->session_state = STATE_DISCONNECT;
448 VDBG (0, "reset session %u [0x%llx]", sid, reset_msg->handle);
Florin Coras134a9962018-08-28 11:32:04 -0700449 vcl_send_session_reset_reply (vcl_session_vpp_evt_q (wrk, session),
Florin Coras47c40e22018-11-26 17:01:36 -0800450 wrk->my_client_index, reset_msg->handle, 0);
Florin Corasc9fbd662018-08-24 12:59:56 -0700451 return sid;
452}
453
Florin Coras60116992018-08-27 09:52:18 -0700454static u32
Florin Coras134a9962018-08-28 11:32:04 -0700455vcl_session_bound_handler (vcl_worker_t * wrk, session_bound_msg_t * mp)
Florin Coras60116992018-08-27 09:52:18 -0700456{
457 vcl_session_t *session;
458 u32 sid = mp->context;
459
Florin Coras134a9962018-08-28 11:32:04 -0700460 session = vcl_session_get (wrk, sid);
Florin Coras60116992018-08-27 09:52:18 -0700461 if (mp->retval)
462 {
Florin Corasd85de682018-11-29 17:02:29 -0800463 VERR ("vpp handle 0x%llx, sid %u: bind failed: %U", mp->handle, sid,
464 format_api_error, mp->retval);
Florin Coras60116992018-08-27 09:52:18 -0700465 if (session)
466 {
467 session->session_state = STATE_FAILED;
468 session->vpp_handle = mp->handle;
469 return sid;
470 }
471 else
472 {
473 clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
474 "Invalid session index (%u)!",
475 getpid (), mp->handle, sid);
476 return VCL_INVALID_SESSION_INDEX;
477 }
478 }
479
480 session->vpp_handle = mp->handle;
481 session->transport.is_ip4 = mp->lcl_is_ip4;
Dave Barach178cf492018-11-13 16:34:13 -0500482 clib_memcpy_fast (&session->transport.lcl_ip, mp->lcl_ip,
483 sizeof (ip46_address_t));
Florin Coras60116992018-08-27 09:52:18 -0700484 session->transport.lcl_port = mp->lcl_port;
Florin Coras134a9962018-08-28 11:32:04 -0700485 vcl_session_table_add_listener (wrk, mp->handle, sid);
Florin Coras60116992018-08-27 09:52:18 -0700486 session->session_state = STATE_LISTEN;
487
488 if (session->is_dgram)
489 {
490 svm_fifo_t *rx_fifo, *tx_fifo;
491 session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
492 rx_fifo = uword_to_pointer (mp->rx_fifo, svm_fifo_t *);
493 rx_fifo->client_session_index = sid;
494 tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
495 tx_fifo->client_session_index = sid;
496 session->rx_fifo = rx_fifo;
497 session->tx_fifo = tx_fifo;
498 }
499
Florin Coras05ecfcc2018-12-12 18:19:39 -0800500 VDBG (0, "session %u [0x%llx]: listen succeeded!", sid, mp->handle);
Florin Coras60116992018-08-27 09:52:18 -0700501 return sid;
502}
503
Florin Coras3c7d4f92018-12-14 11:28:43 -0800504static vcl_session_t *
505vcl_session_accepted (vcl_worker_t * wrk, session_accepted_msg_t * msg)
506{
507 vcl_session_msg_t *vcl_msg;
508 vcl_session_t *session;
509
510 session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
511 if (PREDICT_FALSE (session != 0))
512 VWRN ("session handle overlap %lu!", msg->handle);
513
514 session = vcl_session_table_lookup_listener (wrk, msg->listener_handle);
515 if (!session)
516 {
517 VERR ("couldn't find listen session: listener handle %llx",
518 msg->listener_handle);
519 return 0;
520 }
521
522 clib_fifo_add2 (session->accept_evts_fifo, vcl_msg);
523 vcl_msg->accepted_msg = *msg;
524 /* Session handle points to listener until fully accepted by app */
525 vcl_session_table_add_vpp_handle (wrk, msg->handle, session->session_index);
526
527 return session;
528}
529
530static vcl_session_t *
531vcl_session_disconnected_handler (vcl_worker_t * wrk,
532 session_disconnected_msg_t * msg)
533{
534 vcl_session_t *session;
535
536 session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
537 if (!session)
538 {
539 VDBG (0, "request to disconnect unknown handle 0x%llx", msg->handle);
540 return 0;
541 }
542
543 /* Caught a disconnect before actually accepting the session */
544 if (session->session_state == STATE_LISTEN)
545 {
546
547 if (!vcl_flag_accepted_session (session, msg->handle,
548 VCL_ACCEPTED_F_CLOSED))
549 VDBG (0, "session was not accepted!");
550 return 0;
551 }
552
553 session->session_state = STATE_VPP_CLOSING;
554 return session;
555}
556
Florin Coras86f04502018-09-12 16:08:01 -0700557static int
558vcl_handle_mq_event (vcl_worker_t * wrk, session_event_t * e)
Florin Coras54693d22018-07-17 10:46:29 -0700559{
Florin Coras54693d22018-07-17 10:46:29 -0700560 session_disconnected_msg_t *disconnected_msg;
Florin Coras54693d22018-07-17 10:46:29 -0700561 vcl_session_t *session;
Florin Coras54693d22018-07-17 10:46:29 -0700562
563 switch (e->event_type)
564 {
565 case FIFO_EVENT_APP_RX:
Florin Coras86f04502018-09-12 16:08:01 -0700566 case FIFO_EVENT_APP_TX:
567 case SESSION_IO_EVT_CT_RX:
568 case SESSION_IO_EVT_CT_TX:
569 vec_add1 (wrk->unhandled_evts_vector, *e);
Florin Coras54693d22018-07-17 10:46:29 -0700570 break;
571 case SESSION_CTRL_EVT_ACCEPTED:
Florin Coras3c7d4f92018-12-14 11:28:43 -0800572 vcl_session_accepted (wrk, (session_accepted_msg_t *) e->data);
Florin Coras54693d22018-07-17 10:46:29 -0700573 break;
574 case SESSION_CTRL_EVT_CONNECTED:
Florin Coras134a9962018-08-28 11:32:04 -0700575 vcl_session_connected_handler (wrk,
576 (session_connected_msg_t *) e->data);
Florin Coras54693d22018-07-17 10:46:29 -0700577 break;
578 case SESSION_CTRL_EVT_DISCONNECTED:
579 disconnected_msg = (session_disconnected_msg_t *) e->data;
Florin Coras3c7d4f92018-12-14 11:28:43 -0800580 session = vcl_session_disconnected_handler (wrk, disconnected_msg);
Florin Corasc9fbd662018-08-24 12:59:56 -0700581 if (!session)
Florin Coras3c7d4f92018-12-14 11:28:43 -0800582 break;
Florin Coras54693d22018-07-17 10:46:29 -0700583 session->session_state = STATE_DISCONNECT;
Florin Coras3c7d4f92018-12-14 11:28:43 -0800584 VDBG (0, "disconnected session %u [0x%llx]", session->session_index,
585 session->vpp_handle);
Florin Corasc9fbd662018-08-24 12:59:56 -0700586 break;
587 case SESSION_CTRL_EVT_RESET:
Florin Coras134a9962018-08-28 11:32:04 -0700588 vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
Florin Coras60116992018-08-27 09:52:18 -0700589 break;
590 case SESSION_CTRL_EVT_BOUND:
Florin Coras134a9962018-08-28 11:32:04 -0700591 vcl_session_bound_handler (wrk, (session_bound_msg_t *) e->data);
Florin Coras54693d22018-07-17 10:46:29 -0700592 break;
593 default:
594 clib_warning ("unhandled %u", e->event_type);
595 }
596 return VPPCOM_OK;
597}
598
Florin Coras697faea2018-06-27 17:10:49 -0700599static inline int
600vppcom_wait_for_session_state_change (u32 session_index,
601 session_state_t state,
602 f64 wait_for_time)
603{
Florin Coras134a9962018-08-28 11:32:04 -0700604 vcl_worker_t *wrk = vcl_worker_get_current ();
605 f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
Florin Coras697faea2018-06-27 17:10:49 -0700606 vcl_session_t *volatile session;
Florin Coras54693d22018-07-17 10:46:29 -0700607 svm_msg_q_msg_t msg;
608 session_event_t *e;
Dave Wallace543852a2017-08-03 02:11:34 -0400609
Florin Coras697faea2018-06-27 17:10:49 -0700610 do
Dave Wallace543852a2017-08-03 02:11:34 -0400611 {
Florin Coras134a9962018-08-28 11:32:04 -0700612 session = vcl_session_get (wrk, session_index);
Florin Coras070453d2018-08-24 17:04:27 -0700613 if (PREDICT_FALSE (!session))
Florin Coras697faea2018-06-27 17:10:49 -0700614 {
Florin Coras070453d2018-08-24 17:04:27 -0700615 return VPPCOM_EBADFD;
Florin Coras697faea2018-06-27 17:10:49 -0700616 }
617 if (session->session_state & state)
618 {
Florin Coras697faea2018-06-27 17:10:49 -0700619 return VPPCOM_OK;
620 }
621 if (session->session_state & STATE_FAILED)
622 {
Florin Coras697faea2018-06-27 17:10:49 -0700623 return VPPCOM_ECONNREFUSED;
624 }
Florin Coras54693d22018-07-17 10:46:29 -0700625
Florin Coras134a9962018-08-28 11:32:04 -0700626 if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0))
Florin Corasdc2e2512018-12-03 17:47:26 -0800627 {
628 usleep (100);
629 continue;
630 }
Florin Coras134a9962018-08-28 11:32:04 -0700631 e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
Florin Coras86f04502018-09-12 16:08:01 -0700632 vcl_handle_mq_event (wrk, e);
Florin Coras134a9962018-08-28 11:32:04 -0700633 svm_msg_q_free_msg (wrk->app_event_queue, &msg);
Florin Corasdcf55ce2017-11-16 15:32:50 -0800634 }
Florin Coras134a9962018-08-28 11:32:04 -0700635 while (clib_time_now (&wrk->clib_time) < timeout);
Florin Corasdcf55ce2017-11-16 15:32:50 -0800636
Florin Coras05ecfcc2018-12-12 18:19:39 -0800637 VDBG (0, "timeout waiting for state 0x%x (%s)", state,
Florin Coras697faea2018-06-27 17:10:49 -0700638 vppcom_session_state_str (state));
639 vcl_evt (VCL_EVT_SESSION_TIMEOUT, session, session_state);
Dave Wallace543852a2017-08-03 02:11:34 -0400640
Florin Coras697faea2018-06-27 17:10:49 -0700641 return VPPCOM_ETIMEDOUT;
Dave Wallace60caa062017-11-10 17:07:13 -0500642}
643
Florin Coras697faea2018-06-27 17:10:49 -0700644static int
645vppcom_app_session_enable (void)
Dave Wallace543852a2017-08-03 02:11:34 -0400646{
Florin Coras697faea2018-06-27 17:10:49 -0700647 int rv;
Dave Wallace543852a2017-08-03 02:11:34 -0400648
Florin Coras697faea2018-06-27 17:10:49 -0700649 if (vcm->app_state != STATE_APP_ENABLED)
650 {
651 vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
Florin Coras134a9962018-08-28 11:32:04 -0700652 rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
Florin Coras697faea2018-06-27 17:10:49 -0700653 if (PREDICT_FALSE (rv))
654 {
655 VDBG (0, "VCL<%d>: application session enable timed out! "
656 "returning %d (%s)", getpid (), rv, vppcom_retval_str (rv));
657 return rv;
658 }
659 }
660 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -0400661}
662
Florin Coras697faea2018-06-27 17:10:49 -0700663static int
664vppcom_app_attach (void)
Dave Wallace543852a2017-08-03 02:11:34 -0400665{
Florin Coras697faea2018-06-27 17:10:49 -0700666 int rv;
Dave Wallace543852a2017-08-03 02:11:34 -0400667
Florin Coras697faea2018-06-27 17:10:49 -0700668 vppcom_app_send_attach ();
Florin Coras134a9962018-08-28 11:32:04 -0700669 rv = vcl_wait_for_app_state_change (STATE_APP_ATTACHED);
Florin Coras697faea2018-06-27 17:10:49 -0700670 if (PREDICT_FALSE (rv))
671 {
672 VDBG (0, "VCL<%d>: application attach timed out! returning %d (%s)",
673 getpid (), rv, vppcom_retval_str (rv));
674 return rv;
675 }
Dave Wallace543852a2017-08-03 02:11:34 -0400676
Florin Coras697faea2018-06-27 17:10:49 -0700677 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -0400678}
679
680static int
Florin Corasab2f6db2018-08-31 14:31:41 -0700681vppcom_session_unbind (u32 session_handle)
Dave Wallace543852a2017-08-03 02:11:34 -0400682{
Florin Coras134a9962018-08-28 11:32:04 -0700683 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -0700684 vcl_session_t *session = 0;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500685 u64 vpp_handle;
Dave Wallace543852a2017-08-03 02:11:34 -0400686
Florin Corasab2f6db2018-08-31 14:31:41 -0700687 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -0700688 if (!session)
689 return VPPCOM_EBADFD;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500690
691 vpp_handle = session->vpp_handle;
Florin Coras134a9962018-08-28 11:32:04 -0700692 vcl_session_table_del_listener (wrk, vpp_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -0500693 session->vpp_handle = ~0;
Florin Coras7e12d942018-06-27 14:32:43 -0700694 session->session_state = STATE_DISCONNECT;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500695
Florin Coras0d427d82018-06-27 03:24:07 -0700696 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending unbind msg! new state"
Florin Corasab2f6db2018-08-31 14:31:41 -0700697 " 0x%x (%s)", getpid (), vpp_handle, session_handle, STATE_DISCONNECT,
Florin Coras0d427d82018-06-27 03:24:07 -0700698 vppcom_session_state_str (STATE_DISCONNECT));
699 vcl_evt (VCL_EVT_UNBIND, session);
Dave Wallace4878cbe2017-11-21 03:45:09 -0500700 vppcom_send_unbind_sock (vpp_handle);
701
Florin Coras070453d2018-08-24 17:04:27 -0700702 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -0400703}
704
Florin Coras697faea2018-06-27 17:10:49 -0700705static int
Florin Corasab2f6db2018-08-31 14:31:41 -0700706vppcom_session_disconnect (u32 session_handle)
Dave Wallace543852a2017-08-03 02:11:34 -0400707{
Florin Coras134a9962018-08-28 11:32:04 -0700708 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras99368312018-08-02 10:45:44 -0700709 svm_msg_q_t *vpp_evt_q;
Florin Coras7e12d942018-06-27 14:32:43 -0700710 vcl_session_t *session;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500711 session_state_t state;
Florin Coras99368312018-08-02 10:45:44 -0700712 u64 vpp_handle;
Dave Wallace543852a2017-08-03 02:11:34 -0400713
Florin Corasab2f6db2018-08-31 14:31:41 -0700714 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras21795132018-09-09 09:40:51 -0700715 if (!session)
716 return VPPCOM_EBADFD;
717
Dave Wallace4878cbe2017-11-21 03:45:09 -0500718 vpp_handle = session->vpp_handle;
Florin Coras7e12d942018-06-27 14:32:43 -0700719 state = session->session_state;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500720
Florin Coras0d427d82018-06-27 03:24:07 -0700721 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u state 0x%x (%s)", getpid (),
Florin Corasab2f6db2018-08-31 14:31:41 -0700722 vpp_handle, session_handle, state, vppcom_session_state_str (state));
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400723
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -0800724 if (PREDICT_FALSE (state & STATE_LISTEN))
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400725 {
Dave Wallace048b1d62018-01-03 22:24:41 -0500726 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Dave Wallaceee45d412017-11-24 21:44:06 -0500727 "Cannot disconnect a listen socket!",
Florin Corasab2f6db2018-08-31 14:31:41 -0700728 getpid (), vpp_handle, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -0700729 return VPPCOM_EBADFD;
Dave Wallace4878cbe2017-11-21 03:45:09 -0500730 }
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400731
Florin Coras3c7d4f92018-12-14 11:28:43 -0800732 if (state & STATE_VPP_CLOSING)
Dave Wallace4878cbe2017-11-21 03:45:09 -0500733 {
Florin Coras134a9962018-08-28 11:32:04 -0700734 vpp_evt_q = vcl_session_vpp_evt_q (wrk, session);
Florin Coras47c40e22018-11-26 17:01:36 -0800735 vcl_send_session_disconnected_reply (vpp_evt_q, wrk->my_client_index,
Florin Coras99368312018-08-02 10:45:44 -0700736 vpp_handle, 0);
Florin Coras0d427d82018-06-27 03:24:07 -0700737 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect "
Florin Corasab2f6db2018-08-31 14:31:41 -0700738 "REPLY...", getpid (), vpp_handle, session_handle);
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400739 }
740 else
Dave Wallace227867f2017-11-13 21:21:53 -0500741 {
Florin Coras0d427d82018-06-27 03:24:07 -0700742 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect...",
Florin Corasab2f6db2018-08-31 14:31:41 -0700743 getpid (), vpp_handle, session_handle);
744 vppcom_send_disconnect_session (vpp_handle);
Dave Wallace227867f2017-11-13 21:21:53 -0500745 }
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400746
Florin Coras070453d2018-08-24 17:04:27 -0700747 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -0400748}
749
Florin Coras053a0e42018-11-13 15:52:38 -0800750static void
751vcl_cleanup_bapi (void)
752{
Florin Coras47c40e22018-11-26 17:01:36 -0800753 socket_client_main_t *scm = &socket_client_main;
Florin Coras053a0e42018-11-13 15:52:38 -0800754 api_main_t *am = &api_main;
755
756 am->my_client_index = ~0;
757 am->my_registration = 0;
758 am->vl_input_queue = 0;
759 am->msg_index_by_name_and_crc = 0;
Florin Coras47c40e22018-11-26 17:01:36 -0800760 scm->socket_fd = 0;
Florin Coras053a0e42018-11-13 15:52:38 -0800761
762 vl_client_api_unmap ();
763}
764
Florin Coras01f3f892018-12-02 12:45:53 -0800765static void
766vcl_cleanup_forked_child (vcl_worker_t * wrk, vcl_worker_t * child_wrk)
767{
768 vcl_worker_t *sub_child;
769 int tries = 0;
770
771 if (child_wrk->forked_child != ~0)
772 {
773 sub_child = vcl_worker_get_if_valid (child_wrk->forked_child);
774 if (sub_child)
775 {
776 /* Wait a bit, maybe the process is going away */
777 while (kill (sub_child->current_pid, 0) >= 0 && tries++ < 50)
778 usleep (1e3);
779 if (kill (sub_child->current_pid, 0) < 0)
780 vcl_cleanup_forked_child (child_wrk, sub_child);
781 }
782 }
783 vcl_worker_cleanup (child_wrk, 1 /* notify vpp */ );
784 VDBG (0, "Cleaned up wrk %u", child_wrk->wrk_index);
785 wrk->forked_child = ~0;
786}
787
788static struct sigaction old_sa;
789
790static void
791vcl_intercept_sigchld_handler (int signum, siginfo_t * si, void *uc)
792{
793 vcl_worker_t *wrk, *child_wrk;
794
795 if (vcl_get_worker_index () == ~0)
796 return;
797
798 sigaction (SIGCHLD, &old_sa, 0);
799
800 wrk = vcl_worker_get_current ();
801 if (wrk->forked_child == ~0)
802 return;
803
804 child_wrk = vcl_worker_get_if_valid (wrk->forked_child);
Florin Coraseaec2a62018-12-04 16:34:05 -0800805 if (!child_wrk)
806 goto done;
807
808 if (si && si->si_pid != child_wrk->current_pid)
Florin Coras01f3f892018-12-02 12:45:53 -0800809 {
810 VDBG (0, "unexpected child pid %u", si->si_pid);
Florin Coraseaec2a62018-12-04 16:34:05 -0800811 goto done;
Florin Coras01f3f892018-12-02 12:45:53 -0800812 }
Florin Coraseaec2a62018-12-04 16:34:05 -0800813 vcl_cleanup_forked_child (wrk, child_wrk);
Florin Coras01f3f892018-12-02 12:45:53 -0800814
Florin Coraseaec2a62018-12-04 16:34:05 -0800815done:
Florin Coras01f3f892018-12-02 12:45:53 -0800816 if (old_sa.sa_flags & SA_SIGINFO)
817 {
818 void (*fn) (int, siginfo_t *, void *) = old_sa.sa_sigaction;
819 fn (signum, si, uc);
820 }
821 else
822 {
823 void (*fn) (int) = old_sa.sa_handler;
824 if (fn)
825 fn (signum);
826 }
827}
828
829static void
830vcl_incercept_sigchld ()
831{
832 struct sigaction sa;
833 clib_memset (&sa, 0, sizeof (sa));
834 sa.sa_sigaction = vcl_intercept_sigchld_handler;
835 sa.sa_flags = SA_SIGINFO;
836 if (sigaction (SIGCHLD, &sa, &old_sa))
837 {
838 VERR ("couldn't intercept sigchld");
839 exit (-1);
840 }
841}
842
843static void
844vcl_app_pre_fork (void)
845{
846 vcl_incercept_sigchld ();
847}
848
849static void
Florin Coras053a0e42018-11-13 15:52:38 -0800850vcl_app_fork_child_handler (void)
851{
Florin Coras01f3f892018-12-02 12:45:53 -0800852 int rv, parent_wrk_index;
853 vcl_worker_t *parent_wrk;
Florin Coras053a0e42018-11-13 15:52:38 -0800854 u8 *child_name;
Florin Coras053a0e42018-11-13 15:52:38 -0800855
Florin Coras01f3f892018-12-02 12:45:53 -0800856 parent_wrk_index = vcl_get_worker_index ();
857 VDBG (0, "initializing forked child with parent wrk %u", parent_wrk_index);
Florin Coras053a0e42018-11-13 15:52:38 -0800858
Florin Coras47c40e22018-11-26 17:01:36 -0800859 /*
860 * Allocate worker
861 */
Florin Coras47c40e22018-11-26 17:01:36 -0800862 vcl_set_worker_index (~0);
863 if (!vcl_worker_alloc_and_init ())
864 VERR ("couldn't allocate new worker");
865
866 /*
867 * Attach to binary api
868 */
869 child_name = format (0, "%v-child-%u%c", vcm->app_name, getpid (), 0);
Florin Coras053a0e42018-11-13 15:52:38 -0800870 vcl_cleanup_bapi ();
871 vppcom_api_hookup ();
872 vcm->app_state = STATE_APP_START;
873 rv = vppcom_connect_to_vpp ((char *) child_name);
874 vec_free (child_name);
875 if (rv)
876 {
877 VERR ("couldn't connect to VPP!");
878 return;
879 }
880
Florin Coras47c40e22018-11-26 17:01:36 -0800881 /*
882 * Register worker with vpp and share sessions
883 */
884 vcl_worker_register_with_vpp ();
Florin Coras01f3f892018-12-02 12:45:53 -0800885 parent_wrk = vcl_worker_get (parent_wrk_index);
Florin Coras47c40e22018-11-26 17:01:36 -0800886 vcl_worker_share_sessions (parent_wrk);
Florin Coras01f3f892018-12-02 12:45:53 -0800887 parent_wrk->forked_child = vcl_get_worker_index ();
Florin Coras47c40e22018-11-26 17:01:36 -0800888
Florin Coras053a0e42018-11-13 15:52:38 -0800889 VDBG (0, "forked child main worker initialized");
Florin Coras47c40e22018-11-26 17:01:36 -0800890 vcm->forking = 0;
891}
892
Florin Coras01f3f892018-12-02 12:45:53 -0800893static void
Florin Coras47c40e22018-11-26 17:01:36 -0800894vcl_app_fork_parent_handler (void)
895{
896 vcm->forking = 1;
Florin Coras47c40e22018-11-26 17:01:36 -0800897 while (vcm->forking)
898 ;
Florin Coras053a0e42018-11-13 15:52:38 -0800899}
900
Florin Coras940f78f2018-11-30 12:11:20 -0800901/**
902 * Handle app exit
903 *
904 * Notify vpp of the disconnect and mark the worker as free. If we're the
905 * last worker, do a full cleanup otherwise, since we're probably a forked
906 * child, avoid syscalls as much as possible. We might've lost privileges.
907 */
908void
909vppcom_app_exit (void)
910{
911 if (!pool_elts (vcm->workers))
912 return;
Florin Coras01f3f892018-12-02 12:45:53 -0800913 vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ );
914 vcl_set_worker_index (~0);
Florin Coras940f78f2018-11-30 12:11:20 -0800915 vcl_elog_stop (vcm);
916 if (vec_len (vcm->workers) == 1)
917 vl_client_disconnect_from_vlib ();
918 else
Florin Coraseaec2a62018-12-04 16:34:05 -0800919 vl_client_send_disconnect (1 /* vpp should cleanup */ );
Florin Coras940f78f2018-11-30 12:11:20 -0800920}
921
Dave Wallace543852a2017-08-03 02:11:34 -0400922/*
923 * VPPCOM Public API functions
924 */
925int
926vppcom_app_create (char *app_name)
927{
Dave Wallace543852a2017-08-03 02:11:34 -0400928 vppcom_cfg_t *vcl_cfg = &vcm->cfg;
Dave Wallace543852a2017-08-03 02:11:34 -0400929 int rv;
930
Florin Coras47c40e22018-11-26 17:01:36 -0800931 if (vcm->is_init)
Dave Wallace543852a2017-08-03 02:11:34 -0400932 {
Florin Coras955bfbb2018-12-04 13:43:45 -0800933 VDBG (1, "already initialized");
934 return VPPCOM_EEXIST;
Dave Wallace543852a2017-08-03 02:11:34 -0400935 }
936
Florin Coras47c40e22018-11-26 17:01:36 -0800937 vcm->is_init = 1;
938 vppcom_cfg (&vcm->cfg);
939 vcl_cfg = &vcm->cfg;
940
941 vcm->main_cpu = pthread_self ();
942 vcm->main_pid = getpid ();
943 vcm->app_name = format (0, "%s", app_name);
944 vppcom_init_error_string_table ();
Florin Corasadc74d72018-12-02 13:36:00 -0800945 svm_fifo_segment_main_init (&vcm->segment_main, vcl_cfg->segment_baseva,
Florin Coras47c40e22018-11-26 17:01:36 -0800946 20 /* timeout in secs */ );
947 pool_alloc (vcm->workers, vcl_cfg->max_workers);
948 clib_spinlock_init (&vcm->workers_lock);
Florin Corasd85de682018-11-29 17:02:29 -0800949 clib_rwlock_init (&vcm->segment_table_lock);
Florin Coras01f3f892018-12-02 12:45:53 -0800950 pthread_atfork (vcl_app_pre_fork, vcl_app_fork_parent_handler,
Florin Coras47c40e22018-11-26 17:01:36 -0800951 vcl_app_fork_child_handler);
Florin Coras940f78f2018-11-30 12:11:20 -0800952 atexit (vppcom_app_exit);
Florin Coras47c40e22018-11-26 17:01:36 -0800953
954 /* Allocate default worker */
955 vcl_worker_alloc_and_init ();
956
957 /* API hookup and connect to VPP */
958 vppcom_api_hookup ();
959 vcl_elog_init (vcm);
960 vcm->app_state = STATE_APP_START;
961 rv = vppcom_connect_to_vpp (app_name);
962 if (rv)
Dave Wallace543852a2017-08-03 02:11:34 -0400963 {
Florin Coras47c40e22018-11-26 17:01:36 -0800964 VERR ("couldn't connect to VPP!");
965 return rv;
Dave Wallace66cf6eb2017-10-26 02:51:07 -0400966 }
Florin Coras47c40e22018-11-26 17:01:36 -0800967 VDBG (0, "sending session enable");
968 rv = vppcom_app_session_enable ();
969 if (rv)
970 {
971 VERR ("vppcom_app_session_enable() failed!");
972 return rv;
973 }
974
975 VDBG (0, "sending app attach");
976 rv = vppcom_app_attach ();
977 if (rv)
978 {
979 VERR ("vppcom_app_attach() failed!");
980 return rv;
981 }
982
983 VDBG (0, "app_name '%s', my_client_index %d (0x%x)", app_name,
984 vcm->workers[0].my_client_index, vcm->workers[0].my_client_index);
Dave Wallace543852a2017-08-03 02:11:34 -0400985
986 return VPPCOM_OK;
987}
988
989void
990vppcom_app_destroy (void)
991{
Dave Wallace543852a2017-08-03 02:11:34 -0400992 int rv;
Dave Wallacede910062018-03-20 09:22:13 -0400993 f64 orig_app_timeout;
Dave Wallace543852a2017-08-03 02:11:34 -0400994
Florin Coras940f78f2018-11-30 12:11:20 -0800995 if (!pool_elts (vcm->workers))
996 return;
997
Florin Coras0d427d82018-06-27 03:24:07 -0700998 vcl_evt (VCL_EVT_DETACH, vcm);
Keith Burns (alagalah)8aa9aaf2018-01-05 12:16:22 -0800999
Florin Coras940f78f2018-11-30 12:11:20 -08001000 if (pool_elts (vcm->workers) == 1)
Florin Coras47c40e22018-11-26 17:01:36 -08001001 {
1002 vppcom_app_send_detach ();
1003 orig_app_timeout = vcm->cfg.app_timeout;
1004 vcm->cfg.app_timeout = 2.0;
1005 rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
1006 vcm->cfg.app_timeout = orig_app_timeout;
1007 if (PREDICT_FALSE (rv))
1008 VDBG (0, "application detach timed out! returning %d (%s)", rv,
1009 vppcom_retval_str (rv));
Florin Coras940f78f2018-11-30 12:11:20 -08001010 vec_free (vcm->app_name);
Florin Coras01f3f892018-12-02 12:45:53 -08001011 vcl_worker_cleanup (vcl_worker_get_current (), 0 /* notify vpp */ );
Florin Coras47c40e22018-11-26 17:01:36 -08001012 }
1013 else
1014 {
Florin Coras01f3f892018-12-02 12:45:53 -08001015 vcl_worker_cleanup (vcl_worker_get_current (), 1 /* notify vpp */ );
Florin Coras47c40e22018-11-26 17:01:36 -08001016 }
Keith Burns (alagalah)8aa9aaf2018-01-05 12:16:22 -08001017
Florin Coras01f3f892018-12-02 12:45:53 -08001018 vcl_set_worker_index (~0);
Florin Coras0d427d82018-06-27 03:24:07 -07001019 vcl_elog_stop (vcm);
Dave Wallace543852a2017-08-03 02:11:34 -04001020 vl_client_disconnect_from_vlib ();
Dave Wallace543852a2017-08-03 02:11:34 -04001021}
1022
1023int
Dave Wallacec04cbf12018-02-07 18:14:02 -05001024vppcom_session_create (u8 proto, u8 is_nonblocking)
Dave Wallace543852a2017-08-03 02:11:34 -04001025{
Florin Coras134a9962018-08-28 11:32:04 -07001026 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07001027 vcl_session_t *session;
Dave Wallace543852a2017-08-03 02:11:34 -04001028
Florin Coras134a9962018-08-28 11:32:04 -07001029 session = vcl_session_alloc (wrk);
Dave Wallace543852a2017-08-03 02:11:34 -04001030
Florin Coras7e12d942018-06-27 14:32:43 -07001031 session->session_type = proto;
1032 session->session_state = STATE_START;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001033 session->vpp_handle = ~0;
Florin Coras460dce62018-07-27 05:45:06 -07001034 session->is_dgram = proto == VPPCOM_PROTO_UDP;
Dave Wallace543852a2017-08-03 02:11:34 -04001035
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001036 if (is_nonblocking)
1037 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
Dave Wallace543852a2017-08-03 02:11:34 -04001038
Florin Coras7e12d942018-06-27 14:32:43 -07001039 vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
1040 is_nonblocking, session_index);
Keith Burns (alagalah)09b27842018-01-05 14:39:59 -08001041
Florin Coras053a0e42018-11-13 15:52:38 -08001042 VDBG (0, "created sid %u", session->session_index);
Keith Burns (alagalah)09b27842018-01-05 14:39:59 -08001043
Florin Coras134a9962018-08-28 11:32:04 -07001044 return vcl_session_handle (session);
Dave Wallace543852a2017-08-03 02:11:34 -04001045}
1046
1047int
Florin Coras134a9962018-08-28 11:32:04 -07001048vppcom_session_close (uint32_t session_handle)
Dave Wallace543852a2017-08-03 02:11:34 -04001049{
Florin Coras134a9962018-08-28 11:32:04 -07001050 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras47c40e22018-11-26 17:01:36 -08001051 u8 is_vep, do_disconnect = 1;
Florin Coras7e12d942018-06-27 14:32:43 -07001052 vcl_session_t *session = 0;
Dave Wallace66cf6eb2017-10-26 02:51:07 -04001053 session_state_t state;
Florin Coras134a9962018-08-28 11:32:04 -07001054 u32 next_sh, vep_sh;
1055 int rv = VPPCOM_OK;
1056 u64 vpp_handle;
Dave Wallace543852a2017-08-03 02:11:34 -04001057
Florin Coras134a9962018-08-28 11:32:04 -07001058 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001059 if (!session)
1060 return VPPCOM_EBADFD;
1061
Florin Coras47c40e22018-11-26 17:01:36 -08001062 if (session->shared_index != ~0)
1063 do_disconnect = vcl_worker_unshare_session (wrk, session);
1064
Dave Wallace66cf6eb2017-10-26 02:51:07 -04001065 is_vep = session->is_vep;
Florin Coras134a9962018-08-28 11:32:04 -07001066 next_sh = session->vep.next_sh;
1067 vep_sh = session->vep.vep_sh;
Florin Coras7e12d942018-06-27 14:32:43 -07001068 state = session->session_state;
Dave Wallaceee45d412017-11-24 21:44:06 -05001069 vpp_handle = session->vpp_handle;
Dave Wallace543852a2017-08-03 02:11:34 -04001070
Florin Coras05ecfcc2018-12-12 18:19:39 -08001071 VDBG (1, "closing session handle %u vpp handle %u", session_handle,
Florin Coras47c40e22018-11-26 17:01:36 -08001072 vpp_handle);
Dave Wallace543852a2017-08-03 02:11:34 -04001073
Dave Wallace66cf6eb2017-10-26 02:51:07 -04001074 if (is_vep)
Dave Wallace543852a2017-08-03 02:11:34 -04001075 {
Florin Coras134a9962018-08-28 11:32:04 -07001076 while (next_sh != ~0)
Dave Wallace19481612017-09-15 18:47:44 -04001077 {
Florin Coras134a9962018-08-28 11:32:04 -07001078 rv = vppcom_epoll_ctl (session_handle, EPOLL_CTL_DEL, next_sh, 0);
Florin Coras0d427d82018-06-27 03:24:07 -07001079 if (PREDICT_FALSE (rv < 0))
Florin Coras47c40e22018-11-26 17:01:36 -08001080 VDBG (0, "vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL vep_idx %u"
1081 " failed! rv %d (%s)", vpp_handle, next_sh, vep_sh, rv,
1082 vppcom_retval_str (rv));
Dave Wallacef7f809c2017-10-03 01:48:42 -04001083
Florin Coras134a9962018-08-28 11:32:04 -07001084 next_sh = session->vep.next_sh;
Dave Wallacef7f809c2017-10-03 01:48:42 -04001085 }
1086 }
1087 else
1088 {
Florin Coras47c40e22018-11-26 17:01:36 -08001089 if (session->is_vep_session)
Dave Wallacef7f809c2017-10-03 01:48:42 -04001090 {
Florin Coras134a9962018-08-28 11:32:04 -07001091 rv = vppcom_epoll_ctl (vep_sh, EPOLL_CTL_DEL, session_handle, 0);
Florin Coras0d427d82018-06-27 03:24:07 -07001092 if (rv < 0)
Florin Coras47c40e22018-11-26 17:01:36 -08001093 VDBG (0, "vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL vep_idx %u "
1094 "failed! rv %d (%s)", vpp_handle, session_handle, vep_sh,
1095 rv, vppcom_retval_str (rv));
Dave Wallacef7f809c2017-10-03 01:48:42 -04001096 }
1097
Florin Coras47c40e22018-11-26 17:01:36 -08001098 if (!do_disconnect)
1099 goto cleanup;
1100
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001101 if (state & STATE_LISTEN)
Dave Wallacef7f809c2017-10-03 01:48:42 -04001102 {
Florin Coras134a9962018-08-28 11:32:04 -07001103 rv = vppcom_session_unbind (session_handle);
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001104 if (PREDICT_FALSE (rv < 0))
Florin Coras47c40e22018-11-26 17:01:36 -08001105 VDBG (0, "vpp handle 0x%llx, sid %u: listener unbind failed! "
1106 "rv %d (%s)", vpp_handle, session_handle, rv,
1107 vppcom_retval_str (rv));
Dave Wallacef7f809c2017-10-03 01:48:42 -04001108 }
Florin Coras070453d2018-08-24 17:04:27 -07001109 else if (state & STATE_OPEN)
Dave Wallacef7f809c2017-10-03 01:48:42 -04001110 {
Florin Coras134a9962018-08-28 11:32:04 -07001111 rv = vppcom_session_disconnect (session_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001112 if (PREDICT_FALSE (rv < 0))
Dave Wallace048b1d62018-01-03 22:24:41 -05001113 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Dave Wallaceee45d412017-11-24 21:44:06 -05001114 "session disconnect failed! rv %d (%s)",
Florin Coras134a9962018-08-28 11:32:04 -07001115 getpid (), vpp_handle, session_handle,
Dave Wallaceee45d412017-11-24 21:44:06 -05001116 rv, vppcom_retval_str (rv));
Dave Wallacef7f809c2017-10-03 01:48:42 -04001117 }
Dave Wallace19481612017-09-15 18:47:44 -04001118 }
Dave Wallace4878cbe2017-11-21 03:45:09 -05001119
Florin Coras47c40e22018-11-26 17:01:36 -08001120cleanup:
1121
Florin Coras99368312018-08-02 10:45:44 -07001122 if (vcl_session_is_ct (session))
1123 {
1124 vcl_cut_through_registration_t *ctr;
1125 uword mq_addr;
1126
1127 mq_addr = pointer_to_uword (session->our_evt_q);
Florin Coras134a9962018-08-28 11:32:04 -07001128 ctr = vcl_ct_registration_lock_and_lookup (wrk, mq_addr);
Florin Coras99368312018-08-02 10:45:44 -07001129 ASSERT (ctr);
1130 if (ctr->epoll_evt_conn_index != ~0)
Florin Coras134a9962018-08-28 11:32:04 -07001131 vcl_mq_epoll_del_evfd (wrk, ctr->epoll_evt_conn_index);
Florin Coras99368312018-08-02 10:45:44 -07001132 VDBG (0, "Removing ct registration %u",
Florin Coras134a9962018-08-28 11:32:04 -07001133 vcl_ct_registration_index (wrk, ctr));
1134 vcl_ct_registration_del (wrk, ctr);
1135 vcl_ct_registration_lookup_del (wrk, mq_addr);
1136 vcl_ct_registration_unlock (wrk);
Florin Coras99368312018-08-02 10:45:44 -07001137 }
Florin Coras54693d22018-07-17 10:46:29 -07001138
Dave Wallaceee45d412017-11-24 21:44:06 -05001139 if (vpp_handle != ~0)
Dave Wallace4878cbe2017-11-21 03:45:09 -05001140 {
Florin Coras134a9962018-08-28 11:32:04 -07001141 vcl_session_table_del_vpp_handle (wrk, vpp_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001142 }
Florin Coras134a9962018-08-28 11:32:04 -07001143 vcl_session_free (wrk, session);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001144
Florin Coras05ecfcc2018-12-12 18:19:39 -08001145 VDBG (0, "session handle %u [0x%llx] removed", session_handle, vpp_handle);
Keith Burns (alagalah)09b27842018-01-05 14:39:59 -08001146
Florin Coras0d427d82018-06-27 03:24:07 -07001147 vcl_evt (VCL_EVT_CLOSE, session, rv);
Keith Burns (alagalah)09b27842018-01-05 14:39:59 -08001148
Dave Wallace543852a2017-08-03 02:11:34 -04001149 return rv;
1150}
1151
1152int
Florin Coras134a9962018-08-28 11:32:04 -07001153vppcom_session_bind (uint32_t session_handle, vppcom_endpt_t * ep)
Dave Wallace543852a2017-08-03 02:11:34 -04001154{
Florin Coras134a9962018-08-28 11:32:04 -07001155 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07001156 vcl_session_t *session = 0;
Dave Wallace543852a2017-08-03 02:11:34 -04001157
1158 if (!ep || !ep->ip)
1159 return VPPCOM_EINVAL;
1160
Florin Coras134a9962018-08-28 11:32:04 -07001161 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001162 if (!session)
1163 return VPPCOM_EBADFD;
Dave Wallace543852a2017-08-03 02:11:34 -04001164
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001165 if (session->is_vep)
1166 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001167 clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
Florin Coras134a9962018-08-28 11:32:04 -07001168 "bind to an epoll session!", getpid (), session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001169 return VPPCOM_EBADFD;
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001170 }
1171
Florin Coras7e12d942018-06-27 14:32:43 -07001172 session->transport.is_ip4 = ep->is_ip4;
Florin Coras54693d22018-07-17 10:46:29 -07001173 if (ep->is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05001174 clib_memcpy_fast (&session->transport.lcl_ip.ip4, ep->ip,
1175 sizeof (ip4_address_t));
Florin Coras54693d22018-07-17 10:46:29 -07001176 else
Dave Barach178cf492018-11-13 16:34:13 -05001177 clib_memcpy_fast (&session->transport.lcl_ip.ip6, ep->ip,
1178 sizeof (ip6_address_t));
Florin Coras7e12d942018-06-27 14:32:43 -07001179 session->transport.lcl_port = ep->port;
Stevenac1f96d2017-10-24 16:03:58 -07001180
Florin Coras0d427d82018-06-27 03:24:07 -07001181 VDBG (0, "VCL<%d>: sid %u: binding to local %s address %U port %u, "
Florin Coras134a9962018-08-28 11:32:04 -07001182 "proto %s", getpid (), session_handle,
Florin Coras7e12d942018-06-27 14:32:43 -07001183 session->transport.is_ip4 ? "IPv4" : "IPv6",
1184 format_ip46_address, &session->transport.lcl_ip,
1185 session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1186 clib_net_to_host_u16 (session->transport.lcl_port),
1187 session->session_type ? "UDP" : "TCP");
Florin Coras0d427d82018-06-27 03:24:07 -07001188 vcl_evt (VCL_EVT_BIND, session);
Florin Coras460dce62018-07-27 05:45:06 -07001189
1190 if (session->session_type == VPPCOM_PROTO_UDP)
Florin Coras134a9962018-08-28 11:32:04 -07001191 vppcom_session_listen (session_handle, 10);
Florin Coras460dce62018-07-27 05:45:06 -07001192
Florin Coras070453d2018-08-24 17:04:27 -07001193 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -04001194}
1195
1196int
Florin Coras134a9962018-08-28 11:32:04 -07001197vppcom_session_listen (uint32_t listen_sh, uint32_t q_len)
Dave Wallace543852a2017-08-03 02:11:34 -04001198{
Florin Coras134a9962018-08-28 11:32:04 -07001199 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07001200 vcl_session_t *listen_session = 0;
Dave Wallaceee45d412017-11-24 21:44:06 -05001201 u64 listen_vpp_handle;
Florin Coras070453d2018-08-24 17:04:27 -07001202 int rv;
1203
Florin Coras134a9962018-08-28 11:32:04 -07001204 listen_session = vcl_session_get_w_handle (wrk, listen_sh);
Florin Coras05ecfcc2018-12-12 18:19:39 -08001205 if (!listen_session || listen_session->is_vep)
Florin Coras070453d2018-08-24 17:04:27 -07001206 return VPPCOM_EBADFD;
Dave Wallace543852a2017-08-03 02:11:34 -04001207
Keith Burns (alagalah)aba98de2018-02-22 03:23:40 -08001208 if (q_len == 0 || q_len == ~0)
1209 q_len = vcm->cfg.listen_queue_size;
1210
Dave Wallaceee45d412017-11-24 21:44:06 -05001211 listen_vpp_handle = listen_session->vpp_handle;
Florin Coras7e12d942018-06-27 14:32:43 -07001212 if (listen_session->session_state & STATE_LISTEN)
Dave Wallacee695cb42017-11-02 22:04:42 -04001213 {
Florin Coras05ecfcc2018-12-12 18:19:39 -08001214 VDBG (0, "session %u [0x%llx]: already in listen state!",
1215 listen_sh, listen_vpp_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001216 return VPPCOM_OK;
Dave Wallacee695cb42017-11-02 22:04:42 -04001217 }
1218
Florin Coras05ecfcc2018-12-12 18:19:39 -08001219 VDBG (0, "session %u [0x%llx]: sending vpp listen request...",
1220 listen_sh, listen_vpp_handle);
Dave Wallace543852a2017-08-03 02:11:34 -04001221
Florin Coras070453d2018-08-24 17:04:27 -07001222 /*
1223 * Send listen request to vpp and wait for reply
1224 */
Florin Coras134a9962018-08-28 11:32:04 -07001225 vppcom_send_bind_sock (listen_session);
1226 rv = vppcom_wait_for_session_state_change (listen_session->session_index,
1227 STATE_LISTEN,
1228 vcm->cfg.session_timeout);
Dave Wallace543852a2017-08-03 02:11:34 -04001229
Florin Coras070453d2018-08-24 17:04:27 -07001230 if (PREDICT_FALSE (rv))
Dave Wallaceee45d412017-11-24 21:44:06 -05001231 {
Florin Coras134a9962018-08-28 11:32:04 -07001232 listen_session = vcl_session_get_w_handle (wrk, listen_sh);
Florin Coras05ecfcc2018-12-12 18:19:39 -08001233 VDBG (0, "session %u [0x%llx]: listen failed! returning %d (%s)",
1234 listen_sh, listen_session->vpp_handle, rv,
1235 vppcom_retval_str (rv));
Florin Coras070453d2018-08-24 17:04:27 -07001236 return rv;
Dave Wallaceee45d412017-11-24 21:44:06 -05001237 }
1238
Florin Coras070453d2018-08-24 17:04:27 -07001239 return VPPCOM_OK;
Keith Burns (alagalah)0d2b0d52018-03-06 15:55:22 -08001240}
1241
Florin Coras134a9962018-08-28 11:32:04 -07001242static int
1243validate_args_session_accept_ (vcl_worker_t * wrk,
1244 vcl_session_t * listen_session)
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001245{
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001246 /* Input validation - expects spinlock on sessions_lockp */
1247 if (listen_session->is_vep)
1248 {
1249 clib_warning ("VCL<%d>: ERROR: sid %u: cannot accept on an "
Florin Coras134a9962018-08-28 11:32:04 -07001250 "epoll session!", getpid (),
1251 listen_session->session_index);
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001252 return VPPCOM_EBADFD;
1253 }
1254
Florin Coras7e12d942018-06-27 14:32:43 -07001255 if (listen_session->session_state != STATE_LISTEN)
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001256 {
1257 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1258 "not in listen state! state 0x%x (%s)", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07001259 listen_session->vpp_handle, listen_session->session_index,
Florin Coras7e12d942018-06-27 14:32:43 -07001260 listen_session->session_state,
1261 vppcom_session_state_str (listen_session->session_state));
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001262 return VPPCOM_EBADFD;
1263 }
1264 return VPPCOM_OK;
1265}
1266
1267int
Florin Coras134a9962018-08-28 11:32:04 -07001268vppcom_session_accept (uint32_t listen_session_handle, vppcom_endpt_t * ep,
Dave Wallace048b1d62018-01-03 22:24:41 -05001269 uint32_t flags)
Dave Wallace543852a2017-08-03 02:11:34 -04001270{
Florin Coras3c7d4f92018-12-14 11:28:43 -08001271 u32 client_session_index = ~0, listen_session_index, accept_flags = 0;
Florin Coras134a9962018-08-28 11:32:04 -07001272 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras54693d22018-07-17 10:46:29 -07001273 session_accepted_msg_t accepted_msg;
Florin Coras7e12d942018-06-27 14:32:43 -07001274 vcl_session_t *listen_session = 0;
1275 vcl_session_t *client_session = 0;
Florin Coras54693d22018-07-17 10:46:29 -07001276 svm_msg_q_t *vpp_evt_q;
1277 vcl_session_msg_t *evt;
Dave Wallaceee45d412017-11-24 21:44:06 -05001278 u64 listen_vpp_handle;
Florin Coras54693d22018-07-17 10:46:29 -07001279 svm_msg_q_msg_t msg;
1280 session_event_t *e;
1281 u8 is_nonblocking;
1282 int rv;
Dave Wallace543852a2017-08-03 02:11:34 -04001283
Florin Coras134a9962018-08-28 11:32:04 -07001284 listen_session = vcl_session_get_w_handle (wrk, listen_session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001285 if (!listen_session)
1286 return VPPCOM_EBADFD;
Dave Wallace543852a2017-08-03 02:11:34 -04001287
Florin Coras134a9962018-08-28 11:32:04 -07001288 listen_session_index = listen_session->session_index;
1289 if ((rv = validate_args_session_accept_ (wrk, listen_session)))
Florin Coras070453d2018-08-24 17:04:27 -07001290 return rv;
Dave Wallace543852a2017-08-03 02:11:34 -04001291
Florin Coras54693d22018-07-17 10:46:29 -07001292 if (clib_fifo_elts (listen_session->accept_evts_fifo))
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001293 {
Florin Coras54693d22018-07-17 10:46:29 -07001294 clib_fifo_sub2 (listen_session->accept_evts_fifo, evt);
Florin Coras3c7d4f92018-12-14 11:28:43 -08001295 accept_flags = evt->flags;
Florin Coras54693d22018-07-17 10:46:29 -07001296 accepted_msg = evt->accepted_msg;
1297 goto handle;
1298 }
1299
1300 is_nonblocking = VCL_SESS_ATTR_TEST (listen_session->attr,
1301 VCL_SESS_ATTR_NONBLOCK);
Florin Coras134a9962018-08-28 11:32:04 -07001302 if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
Florin Coras54693d22018-07-17 10:46:29 -07001303 return VPPCOM_EAGAIN;
1304
1305 while (1)
1306 {
Florin Coras134a9962018-08-28 11:32:04 -07001307 if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_WAIT, 0))
Florin Coras54693d22018-07-17 10:46:29 -07001308 return VPPCOM_EAGAIN;
1309
Florin Coras134a9962018-08-28 11:32:04 -07001310 e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
Florin Coras54693d22018-07-17 10:46:29 -07001311 if (e->event_type != SESSION_CTRL_EVT_ACCEPTED)
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001312 {
Florin Coras54693d22018-07-17 10:46:29 -07001313 clib_warning ("discarded event: %u", e->event_type);
Florin Coras134a9962018-08-28 11:32:04 -07001314 svm_msg_q_free_msg (wrk->app_event_queue, &msg);
Florin Coras54693d22018-07-17 10:46:29 -07001315 continue;
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001316 }
Dave Barach178cf492018-11-13 16:34:13 -05001317 clib_memcpy_fast (&accepted_msg, e->data, sizeof (accepted_msg));
Florin Coras134a9962018-08-28 11:32:04 -07001318 svm_msg_q_free_msg (wrk->app_event_queue, &msg);
Florin Coras54693d22018-07-17 10:46:29 -07001319 break;
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001320 }
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001321
Florin Coras54693d22018-07-17 10:46:29 -07001322handle:
Keith Burns (alagalah)00f44cc2018-03-07 09:26:38 -08001323
Florin Coras134a9962018-08-28 11:32:04 -07001324 client_session_index = vcl_session_accepted_handler (wrk, &accepted_msg);
1325 listen_session = vcl_session_get (wrk, listen_session_index);
1326 client_session = vcl_session_get (wrk, client_session_index);
Dave Wallace543852a2017-08-03 02:11:34 -04001327
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001328 if (flags & O_NONBLOCK)
1329 VCL_SESS_ATTR_SET (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001330
Florin Coras54693d22018-07-17 10:46:29 -07001331 listen_vpp_handle = listen_session->vpp_handle;
Florin Coras05ecfcc2018-12-12 18:19:39 -08001332 VDBG (1, "vpp handle 0x%llx, sid %u: Got a client request! "
Florin Coras0d427d82018-06-27 03:24:07 -07001333 "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
Florin Corasdc2e2512018-12-03 17:47:26 -08001334 listen_vpp_handle, listen_session_handle,
Florin Coras0d427d82018-06-27 03:24:07 -07001335 client_session->vpp_handle, client_session_index,
1336 flags, VCL_SESS_ATTR_TEST (client_session->attr,
1337 VCL_SESS_ATTR_NONBLOCK));
Dave Wallace543852a2017-08-03 02:11:34 -04001338
Dave Wallace048b1d62018-01-03 22:24:41 -05001339 if (ep)
1340 {
Florin Coras7e12d942018-06-27 14:32:43 -07001341 ep->is_ip4 = client_session->transport.is_ip4;
1342 ep->port = client_session->transport.rmt_port;
1343 if (client_session->transport.is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05001344 clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip4,
1345 sizeof (ip4_address_t));
Dave Wallace048b1d62018-01-03 22:24:41 -05001346 else
Dave Barach178cf492018-11-13 16:34:13 -05001347 clib_memcpy_fast (ep->ip, &client_session->transport.rmt_ip.ip6,
1348 sizeof (ip6_address_t));
Dave Wallace048b1d62018-01-03 22:24:41 -05001349 }
Dave Wallace60caa062017-11-10 17:07:13 -05001350
Florin Coras54693d22018-07-17 10:46:29 -07001351 if (accepted_msg.server_event_queue_address)
1352 vpp_evt_q = uword_to_pointer (accepted_msg.vpp_event_queue_address,
1353 svm_msg_q_t *);
1354 else
1355 vpp_evt_q = client_session->vpp_evt_q;
Florin Coras99368312018-08-02 10:45:44 -07001356
Florin Coras54693d22018-07-17 10:46:29 -07001357 vcl_send_session_accepted_reply (vpp_evt_q, client_session->client_context,
1358 client_session->vpp_handle, 0);
Dave Wallace60caa062017-11-10 17:07:13 -05001359
Florin Coras05ecfcc2018-12-12 18:19:39 -08001360 VDBG (0, "listener %u [0x%llx] accepted %u [0x%llx] peer: %U:%u "
1361 "local: %U:%u", listen_session_handle, listen_vpp_handle,
1362 client_session_index, client_session->vpp_handle,
Florin Coras7e12d942018-06-27 14:32:43 -07001363 format_ip46_address, &client_session->transport.rmt_ip,
Florin Coras54693d22018-07-17 10:46:29 -07001364 client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
Florin Coras7e12d942018-06-27 14:32:43 -07001365 clib_net_to_host_u16 (client_session->transport.rmt_port),
Florin Coras7e12d942018-06-27 14:32:43 -07001366 format_ip46_address, &client_session->transport.lcl_ip,
Florin Coras54693d22018-07-17 10:46:29 -07001367 client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
Florin Coras7e12d942018-06-27 14:32:43 -07001368 clib_net_to_host_u16 (client_session->transport.lcl_port));
Florin Coras0d427d82018-06-27 03:24:07 -07001369 vcl_evt (VCL_EVT_ACCEPT, client_session, listen_session,
1370 client_session_index);
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08001371
Florin Coras3c7d4f92018-12-14 11:28:43 -08001372 /*
1373 * Session might have been closed already
1374 */
1375 if (accept_flags)
1376 {
1377 svm_msg_q_t *mq = vcl_session_vpp_evt_q (wrk, client_session);
1378 if (accept_flags & VCL_ACCEPTED_F_CLOSED)
1379 {
1380 client_session->session_state = STATE_DISCONNECT;
1381 vcl_send_session_disconnected_reply (mq, wrk->my_client_index,
1382 client_session->vpp_handle, 0);
1383 }
1384 else if (accept_flags & VCL_ACCEPTED_F_RESET)
1385 {
1386 client_session->session_state = STATE_DISCONNECT;
1387 vcl_send_session_reset_reply (mq, wrk->my_client_index,
1388 client_session->vpp_handle, 0);
1389 }
1390 }
Florin Corasab2f6db2018-08-31 14:31:41 -07001391 return vcl_session_handle (client_session);
Dave Wallace543852a2017-08-03 02:11:34 -04001392}
1393
1394int
Florin Coras134a9962018-08-28 11:32:04 -07001395vppcom_session_connect (uint32_t session_handle, vppcom_endpt_t * server_ep)
Dave Wallace543852a2017-08-03 02:11:34 -04001396{
Florin Coras134a9962018-08-28 11:32:04 -07001397 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07001398 vcl_session_t *session = 0;
Florin Coras134a9962018-08-28 11:32:04 -07001399 u32 session_index;
Florin Coras070453d2018-08-24 17:04:27 -07001400 int rv;
Dave Wallace543852a2017-08-03 02:11:34 -04001401
Florin Coras134a9962018-08-28 11:32:04 -07001402 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001403 if (!session)
1404 return VPPCOM_EBADFD;
Florin Coras134a9962018-08-28 11:32:04 -07001405 session_index = session->session_index;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001406
1407 if (PREDICT_FALSE (session->is_vep))
Dave Wallace543852a2017-08-03 02:11:34 -04001408 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001409 clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
Florin Coras134a9962018-08-28 11:32:04 -07001410 "connect on an epoll session!", getpid (),
1411 session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001412 return VPPCOM_EBADFD;
Dave Wallace543852a2017-08-03 02:11:34 -04001413 }
1414
Florin Coras7e12d942018-06-27 14:32:43 -07001415 if (PREDICT_FALSE (session->session_state & CLIENT_STATE_OPEN))
Dave Wallace543852a2017-08-03 02:11:34 -04001416 {
Florin Coras0d427d82018-06-27 03:24:07 -07001417 VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: session already "
1418 "connected to %s %U port %d proto %s, state 0x%x (%s)",
Florin Coras134a9962018-08-28 11:32:04 -07001419 getpid (), session->vpp_handle, session_handle,
Florin Coras7e12d942018-06-27 14:32:43 -07001420 session->transport.is_ip4 ? "IPv4" : "IPv6",
Florin Coras0d427d82018-06-27 03:24:07 -07001421 format_ip46_address,
Florin Coras7e12d942018-06-27 14:32:43 -07001422 &session->transport.rmt_ip, session->transport.is_ip4 ?
Florin Coras0d427d82018-06-27 03:24:07 -07001423 IP46_TYPE_IP4 : IP46_TYPE_IP6,
Florin Coras7e12d942018-06-27 14:32:43 -07001424 clib_net_to_host_u16 (session->transport.rmt_port),
1425 session->session_type ? "UDP" : "TCP", session->session_state,
1426 vppcom_session_state_str (session->session_state));
Florin Coras070453d2018-08-24 17:04:27 -07001427 return VPPCOM_OK;
Dave Wallace543852a2017-08-03 02:11:34 -04001428 }
1429
Florin Coras7e12d942018-06-27 14:32:43 -07001430 session->transport.is_ip4 = server_ep->is_ip4;
1431 if (session->transport.is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05001432 clib_memcpy_fast (&session->transport.rmt_ip.ip4, server_ep->ip,
1433 sizeof (ip4_address_t));
Dave Wallaced239f8d2018-06-19 13:37:30 -04001434 else
Dave Barach178cf492018-11-13 16:34:13 -05001435 clib_memcpy_fast (&session->transport.rmt_ip.ip6, server_ep->ip,
1436 sizeof (ip6_address_t));
Florin Coras7e12d942018-06-27 14:32:43 -07001437 session->transport.rmt_port = server_ep->port;
Dave Wallace543852a2017-08-03 02:11:34 -04001438
Florin Coras0d427d82018-06-27 03:24:07 -07001439 VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server %s %U "
1440 "port %d proto %s",
Florin Coras134a9962018-08-28 11:32:04 -07001441 getpid (), session->vpp_handle, session_handle,
Florin Coras7e12d942018-06-27 14:32:43 -07001442 session->transport.is_ip4 ? "IPv4" : "IPv6",
Florin Coras0d427d82018-06-27 03:24:07 -07001443 format_ip46_address,
Florin Coras7e12d942018-06-27 14:32:43 -07001444 &session->transport.rmt_ip, session->transport.is_ip4 ?
Florin Coras0d427d82018-06-27 03:24:07 -07001445 IP46_TYPE_IP4 : IP46_TYPE_IP6,
Florin Coras7e12d942018-06-27 14:32:43 -07001446 clib_net_to_host_u16 (session->transport.rmt_port),
1447 session->session_type ? "UDP" : "TCP");
Dave Wallace543852a2017-08-03 02:11:34 -04001448
Florin Coras070453d2018-08-24 17:04:27 -07001449 /*
1450 * Send connect request and wait for reply from vpp
1451 */
Florin Coras134a9962018-08-28 11:32:04 -07001452 vppcom_send_connect_sock (session);
Florin Coras070453d2018-08-24 17:04:27 -07001453 rv = vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
1454 vcm->cfg.session_timeout);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001455
Florin Coras134a9962018-08-28 11:32:04 -07001456 session = vcl_session_get (wrk, session_index);
Dave Wallace7876d392017-10-19 03:53:57 -04001457
Florin Coras070453d2018-08-24 17:04:27 -07001458 if (PREDICT_FALSE (rv))
Dave Wallaceee45d412017-11-24 21:44:06 -05001459 {
Dave Wallaceee45d412017-11-24 21:44:06 -05001460 if (VPPCOM_DEBUG > 0)
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001461 {
1462 if (session)
Florin Coras0d427d82018-06-27 03:24:07 -07001463 clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect "
Florin Coras134a9962018-08-28 11:32:04 -07001464 "failed! returning %d (%s)", getpid (),
1465 session->vpp_handle, session_handle, rv,
1466 vppcom_retval_str (rv));
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001467 else
1468 clib_warning ("VCL<%d>: no session for sid %u: connect failed! "
1469 "returning %d (%s)", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07001470 session_handle, rv, vppcom_retval_str (rv));
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001471 }
Dave Wallaceee45d412017-11-24 21:44:06 -05001472 }
Florin Coras0d427d82018-06-27 03:24:07 -07001473 else
1474 VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
Florin Coras134a9962018-08-28 11:32:04 -07001475 getpid (), session->vpp_handle, session_handle);
Dave Wallaceee45d412017-11-24 21:44:06 -05001476
Dave Wallace4878cbe2017-11-21 03:45:09 -05001477 return rv;
Dave Wallace543852a2017-08-03 02:11:34 -04001478}
1479
Florin Coras54693d22018-07-17 10:46:29 -07001480static u8
1481vcl_is_rx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
1482{
1483 if (!is_ct)
1484 return (e->event_type == FIFO_EVENT_APP_RX
1485 && e->fifo->client_session_index == sid);
1486 else
1487 return (e->event_type == SESSION_IO_EVT_CT_TX);
1488}
1489
Florin Coras460dce62018-07-27 05:45:06 -07001490static inline u8
1491vcl_session_is_readable (vcl_session_t * s)
1492{
1493 return ((s->session_state & STATE_OPEN)
1494 || (s->session_state == STATE_LISTEN
1495 && s->session_type == VPPCOM_PROTO_UDP));
1496}
1497
Steven58f464e2017-10-25 12:33:12 -07001498static inline int
Florin Coras134a9962018-08-28 11:32:04 -07001499vppcom_session_read_internal (uint32_t session_handle, void *buf, int n,
Steven58f464e2017-10-25 12:33:12 -07001500 u8 peek)
Dave Wallace543852a2017-08-03 02:11:34 -04001501{
Florin Coras134a9962018-08-28 11:32:04 -07001502 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras54693d22018-07-17 10:46:29 -07001503 int n_read = 0, rv, is_nonblocking;
Florin Coras460dce62018-07-27 05:45:06 -07001504 vcl_session_t *s = 0;
Dave Wallace543852a2017-08-03 02:11:34 -04001505 svm_fifo_t *rx_fifo;
Florin Coras54693d22018-07-17 10:46:29 -07001506 svm_msg_q_msg_t msg;
1507 session_event_t *e;
1508 svm_msg_q_t *mq;
Florin Coras41c9e042018-09-11 00:10:41 -07001509 u8 is_ct;
Dave Wallace543852a2017-08-03 02:11:34 -04001510
Florin Coras070453d2018-08-24 17:04:27 -07001511 if (PREDICT_FALSE (!buf))
1512 return VPPCOM_EINVAL;
Dave Wallace543852a2017-08-03 02:11:34 -04001513
Florin Coras134a9962018-08-28 11:32:04 -07001514 s = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras2cba8532018-09-11 16:33:36 -07001515 if (PREDICT_FALSE (!s || s->is_vep))
Florin Coras070453d2018-08-24 17:04:27 -07001516 return VPPCOM_EBADFD;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001517
Florin Coras460dce62018-07-27 05:45:06 -07001518 if (PREDICT_FALSE (!vcl_session_is_readable (s)))
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001519 {
Florin Coras460dce62018-07-27 05:45:06 -07001520 session_state_t state = s->session_state;
Keith Burns (alagalah)56a0d062018-02-15 07:52:50 -08001521 rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001522
Florin Coras0d427d82018-06-27 03:24:07 -07001523 VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: %s session is not open! "
1524 "state 0x%x (%s), returning %d (%s)",
Florin Coras134a9962018-08-28 11:32:04 -07001525 getpid (), s->vpp_handle, session_handle, state,
Florin Coras0d427d82018-06-27 03:24:07 -07001526 vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
Florin Coras070453d2018-08-24 17:04:27 -07001527 return rv;
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001528 }
1529
Florin Coras2cba8532018-09-11 16:33:36 -07001530 is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
Florin Coras41c9e042018-09-11 00:10:41 -07001531 is_ct = vcl_session_is_ct (s);
1532 mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
Florin Coras2cba8532018-09-11 16:33:36 -07001533 rx_fifo = s->rx_fifo;
Florin Corasaa27eb92018-10-13 12:20:01 -07001534 s->has_rx_evt = 0;
Dave Wallacef7f809c2017-10-03 01:48:42 -04001535
Florin Coras54693d22018-07-17 10:46:29 -07001536 if (svm_fifo_is_empty (rx_fifo))
Dave Wallacef7f809c2017-10-03 01:48:42 -04001537 {
Florin Coras54693d22018-07-17 10:46:29 -07001538 if (is_nonblocking)
Dave Wallace4878cbe2017-11-21 03:45:09 -05001539 {
Florin Coras41c9e042018-09-11 00:10:41 -07001540 svm_fifo_unset_event (rx_fifo);
Florin Corasaa27eb92018-10-13 12:20:01 -07001541 return VPPCOM_EWOULDBLOCK;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001542 }
Florin Coras41c9e042018-09-11 00:10:41 -07001543 while (svm_fifo_is_empty (rx_fifo))
Florin Coras54693d22018-07-17 10:46:29 -07001544 {
Florin Coras41c9e042018-09-11 00:10:41 -07001545 svm_fifo_unset_event (rx_fifo);
Florin Coras99368312018-08-02 10:45:44 -07001546 svm_msg_q_lock (mq);
Florin Coras54693d22018-07-17 10:46:29 -07001547 if (svm_msg_q_is_empty (mq))
1548 svm_msg_q_wait (mq);
Florin Coras99368312018-08-02 10:45:44 -07001549
Florin Coras54693d22018-07-17 10:46:29 -07001550 svm_msg_q_sub_w_lock (mq, &msg);
1551 e = svm_msg_q_msg_data (mq, &msg);
Florin Coras99368312018-08-02 10:45:44 -07001552 svm_msg_q_unlock (mq);
Florin Coras41c9e042018-09-11 00:10:41 -07001553 if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
Florin Coras54693d22018-07-17 10:46:29 -07001554 {
Florin Coras86f04502018-09-12 16:08:01 -07001555 vcl_handle_mq_event (wrk, e);
Florin Coras54693d22018-07-17 10:46:29 -07001556 svm_msg_q_free_msg (mq, &msg);
1557 continue;
1558 }
Florin Coras54693d22018-07-17 10:46:29 -07001559 svm_msg_q_free_msg (mq, &msg);
Florin Coras41c9e042018-09-11 00:10:41 -07001560
Florin Coras3c7d4f92018-12-14 11:28:43 -08001561 if (PREDICT_FALSE (s->session_state == STATE_VPP_CLOSING))
Florin Coras60f1fc12018-08-16 14:57:31 -07001562 return 0;
Florin Coras54693d22018-07-17 10:46:29 -07001563 }
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001564 }
Florin Coras54693d22018-07-17 10:46:29 -07001565
Florin Coras460dce62018-07-27 05:45:06 -07001566 if (s->is_dgram)
Florin Coras99368312018-08-02 10:45:44 -07001567 n_read = app_recv_dgram_raw (rx_fifo, buf, n, &s->transport, 0, peek);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001568 else
Florin Coras99368312018-08-02 10:45:44 -07001569 n_read = app_recv_stream_raw (rx_fifo, buf, n, 0, peek);
Florin Coras54693d22018-07-17 10:46:29 -07001570
Florin Coras41c9e042018-09-11 00:10:41 -07001571 if (svm_fifo_is_empty (rx_fifo))
1572 svm_fifo_unset_event (rx_fifo);
1573
Florin Coras58c101a2018-10-06 13:49:16 -07001574 if (is_ct && svm_fifo_want_tx_evt (rx_fifo))
Florin Coras99368312018-08-02 10:45:44 -07001575 {
Florin Coras58c101a2018-10-06 13:49:16 -07001576 svm_fifo_set_want_tx_evt (s->rx_fifo, 0);
1577 app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo, SESSION_IO_EVT_CT_RX,
1578 SVM_Q_WAIT);
Florin Coras99368312018-08-02 10:45:44 -07001579 }
Florin Coras54693d22018-07-17 10:46:29 -07001580
Florin Coras2cba8532018-09-11 16:33:36 -07001581 VDBG (2, "VCL<%d>: vpp handle 0x%llx, sid %u: read %d bytes from (%p)",
1582 getpid (), s->vpp_handle, session_handle, n_read, rx_fifo);
1583
Florin Coras54693d22018-07-17 10:46:29 -07001584 return n_read;
Dave Wallace543852a2017-08-03 02:11:34 -04001585}
1586
Steven58f464e2017-10-25 12:33:12 -07001587int
Florin Coras134a9962018-08-28 11:32:04 -07001588vppcom_session_read (uint32_t session_handle, void *buf, size_t n)
Steven58f464e2017-10-25 12:33:12 -07001589{
Florin Coras134a9962018-08-28 11:32:04 -07001590 return (vppcom_session_read_internal (session_handle, buf, n, 0));
Steven58f464e2017-10-25 12:33:12 -07001591}
1592
1593static int
Florin Coras134a9962018-08-28 11:32:04 -07001594vppcom_session_peek (uint32_t session_handle, void *buf, int n)
Steven58f464e2017-10-25 12:33:12 -07001595{
Florin Coras134a9962018-08-28 11:32:04 -07001596 return (vppcom_session_read_internal (session_handle, buf, n, 1));
Steven58f464e2017-10-25 12:33:12 -07001597}
1598
Florin Coras2cba8532018-09-11 16:33:36 -07001599int
1600vppcom_session_read_segments (uint32_t session_handle,
1601 vppcom_data_segments_t ds)
1602{
1603 vcl_worker_t *wrk = vcl_worker_get_current ();
1604 int n_read = 0, rv, is_nonblocking;
1605 vcl_session_t *s = 0;
1606 svm_fifo_t *rx_fifo;
1607 svm_msg_q_msg_t msg;
1608 session_event_t *e;
1609 svm_msg_q_t *mq;
1610 u8 is_ct;
1611
1612 s = vcl_session_get_w_handle (wrk, session_handle);
1613 if (PREDICT_FALSE (!s || s->is_vep))
1614 return VPPCOM_EBADFD;
1615
1616 if (PREDICT_FALSE (!vcl_session_is_readable (s)))
1617 {
1618 session_state_t state = s->session_state;
1619 rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1620 return rv;
1621 }
1622
1623 is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
1624 is_ct = vcl_session_is_ct (s);
1625 mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
1626 rx_fifo = s->rx_fifo;
Florin Corasaa27eb92018-10-13 12:20:01 -07001627 s->has_rx_evt = 0;
Florin Coras2cba8532018-09-11 16:33:36 -07001628
1629 if (svm_fifo_is_empty (rx_fifo))
1630 {
1631 if (is_nonblocking)
1632 {
1633 svm_fifo_unset_event (rx_fifo);
Florin Corasaa27eb92018-10-13 12:20:01 -07001634 return VPPCOM_EWOULDBLOCK;
Florin Coras2cba8532018-09-11 16:33:36 -07001635 }
1636 while (svm_fifo_is_empty (rx_fifo))
1637 {
1638 svm_fifo_unset_event (rx_fifo);
1639 svm_msg_q_lock (mq);
1640 if (svm_msg_q_is_empty (mq))
1641 svm_msg_q_wait (mq);
1642
1643 svm_msg_q_sub_w_lock (mq, &msg);
1644 e = svm_msg_q_msg_data (mq, &msg);
1645 svm_msg_q_unlock (mq);
1646 if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
1647 {
Florin Coras86f04502018-09-12 16:08:01 -07001648 vcl_handle_mq_event (wrk, e);
Florin Coras2cba8532018-09-11 16:33:36 -07001649 svm_msg_q_free_msg (mq, &msg);
1650 continue;
1651 }
1652 svm_msg_q_free_msg (mq, &msg);
1653
Florin Coras3c7d4f92018-12-14 11:28:43 -08001654 if (PREDICT_FALSE (s->session_state == STATE_VPP_CLOSING))
Florin Coras2cba8532018-09-11 16:33:36 -07001655 return 0;
1656 }
1657 }
1658
1659 n_read = svm_fifo_segments (rx_fifo, (svm_fifo_segment_t *) ds);
1660 svm_fifo_unset_event (rx_fifo);
1661
1662 if (is_ct && n_read + svm_fifo_max_dequeue (rx_fifo) == rx_fifo->nitems)
1663 {
1664 /* If the peer is not polling send notification */
1665 if (!svm_fifo_has_event (s->rx_fifo))
1666 app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo,
1667 SESSION_IO_EVT_CT_RX, SVM_Q_WAIT);
1668 }
1669
1670 return n_read;
1671}
1672
1673void
1674vppcom_session_free_segments (uint32_t session_handle,
1675 vppcom_data_segments_t ds)
1676{
1677 vcl_worker_t *wrk = vcl_worker_get_current ();
1678 vcl_session_t *s;
1679
1680 s = vcl_session_get_w_handle (wrk, session_handle);
1681 if (PREDICT_FALSE (!s || s->is_vep))
1682 return;
1683
1684 svm_fifo_segments_free (s->rx_fifo, (svm_fifo_segment_t *) ds);
1685}
1686
Dave Wallace543852a2017-08-03 02:11:34 -04001687static inline int
Florin Coras54693d22018-07-17 10:46:29 -07001688vppcom_session_read_ready (vcl_session_t * session)
Dave Wallace543852a2017-08-03 02:11:34 -04001689{
Dave Wallace543852a2017-08-03 02:11:34 -04001690 /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
Dave Wallace4878cbe2017-11-21 03:45:09 -05001691 if (PREDICT_FALSE (session->is_vep))
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001692 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001693 clib_warning ("VCL<%d>: ERROR: sid %u: cannot read from an "
Florin Coras134a9962018-08-28 11:32:04 -07001694 "epoll session!", getpid (), session->session_index);
Florin Coras54693d22018-07-17 10:46:29 -07001695 return VPPCOM_EBADFD;
1696 }
1697
1698 if (PREDICT_FALSE (!(session->session_state & (STATE_OPEN | STATE_LISTEN))))
1699 {
1700 session_state_t state = session->session_state;
1701 int rv;
1702
1703 rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1704
1705 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open!"
1706 " state 0x%x (%s), returning %d (%s)", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07001707 session->vpp_handle, session->session_index, state,
Florin Coras54693d22018-07-17 10:46:29 -07001708 vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
1709 return rv;
Dave Wallace543852a2017-08-03 02:11:34 -04001710 }
Dave Wallace33e002b2017-09-06 01:20:02 -04001711
Florin Coras7e12d942018-06-27 14:32:43 -07001712 if (session->session_state & STATE_LISTEN)
Florin Coras54693d22018-07-17 10:46:29 -07001713 return clib_fifo_elts (session->accept_evts_fifo);
1714
1715 return svm_fifo_max_dequeue (session->rx_fifo);
1716}
1717
Florin Coras2cba8532018-09-11 16:33:36 -07001718int
1719vppcom_data_segment_copy (void *buf, vppcom_data_segments_t ds, u32 max_bytes)
1720{
1721 u32 first_copy = clib_min (ds[0].len, max_bytes);
Dave Barach178cf492018-11-13 16:34:13 -05001722 clib_memcpy_fast (buf, ds[0].data, first_copy);
Florin Coras2cba8532018-09-11 16:33:36 -07001723 if (first_copy < max_bytes)
1724 {
Dave Barach178cf492018-11-13 16:34:13 -05001725 clib_memcpy_fast (buf + first_copy, ds[1].data,
1726 clib_min (ds[1].len, max_bytes - first_copy));
Florin Coras2cba8532018-09-11 16:33:36 -07001727 }
1728 return 0;
1729}
1730
Florin Coras54693d22018-07-17 10:46:29 -07001731static u8
1732vcl_is_tx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
1733{
1734 if (!is_ct)
1735 return (e->event_type == FIFO_EVENT_APP_TX
1736 && e->fifo->client_session_index == sid);
Dave Wallace543852a2017-08-03 02:11:34 -04001737 else
Florin Coras54693d22018-07-17 10:46:29 -07001738 return (e->event_type == SESSION_IO_EVT_CT_RX);
Dave Wallace543852a2017-08-03 02:11:34 -04001739}
1740
Florin Coras42ceddb2018-12-12 10:56:01 -08001741static inline int
1742vppcom_session_write_inline (uint32_t session_handle, void *buf, size_t n,
1743 u8 is_flush)
Dave Wallace543852a2017-08-03 02:11:34 -04001744{
Florin Coras134a9962018-08-28 11:32:04 -07001745 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras54693d22018-07-17 10:46:29 -07001746 int rv, n_write, is_nonblocking;
Florin Coras460dce62018-07-27 05:45:06 -07001747 vcl_session_t *s = 0;
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001748 svm_fifo_t *tx_fifo = 0;
Florin Coras460dce62018-07-27 05:45:06 -07001749 session_evt_type_t et;
Florin Coras54693d22018-07-17 10:46:29 -07001750 svm_msg_q_msg_t msg;
1751 session_event_t *e;
Florin Coras3c2fed52018-07-04 04:15:05 -07001752 svm_msg_q_t *mq;
Florin Coras0e88e852018-09-17 22:09:02 -07001753 u8 is_ct;
Dave Wallace543852a2017-08-03 02:11:34 -04001754
Florin Coras070453d2018-08-24 17:04:27 -07001755 if (PREDICT_FALSE (!buf))
1756 return VPPCOM_EINVAL;
Dave Wallace543852a2017-08-03 02:11:34 -04001757
Florin Coras134a9962018-08-28 11:32:04 -07001758 s = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07001759 if (PREDICT_FALSE (!s))
1760 return VPPCOM_EBADFD;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001761
Florin Coras460dce62018-07-27 05:45:06 -07001762 if (PREDICT_FALSE (s->is_vep))
Dave Wallace543852a2017-08-03 02:11:34 -04001763 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001764 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Dave Wallaceee45d412017-11-24 21:44:06 -05001765 "cannot write to an epoll session!",
Florin Coras134a9962018-08-28 11:32:04 -07001766 getpid (), s->vpp_handle, session_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -05001767
Florin Coras070453d2018-08-24 17:04:27 -07001768 return VPPCOM_EBADFD;
Dave Wallace543852a2017-08-03 02:11:34 -04001769 }
1770
Florin Coras0e88e852018-09-17 22:09:02 -07001771 if (PREDICT_FALSE (!(s->session_state & STATE_OPEN)))
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001772 {
Florin Coras460dce62018-07-27 05:45:06 -07001773 session_state_t state = s->session_state;
Florin Coras54693d22018-07-17 10:46:29 -07001774 rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
Florin Coras0d427d82018-06-27 03:24:07 -07001775 VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open! "
Florin Coras0e88e852018-09-17 22:09:02 -07001776 "state 0x%x (%s)", getpid (), s->vpp_handle, session_handle,
Florin Coras0d427d82018-06-27 03:24:07 -07001777 state, vppcom_session_state_str (state));
Florin Coras070453d2018-08-24 17:04:27 -07001778 return rv;
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001779 }
1780
Florin Coras0e88e852018-09-17 22:09:02 -07001781 tx_fifo = s->tx_fifo;
1782 is_ct = vcl_session_is_ct (s);
1783 is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
1784 mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
Florin Coras54693d22018-07-17 10:46:29 -07001785 if (svm_fifo_is_full (tx_fifo))
Dave Wallace543852a2017-08-03 02:11:34 -04001786 {
Florin Coras54693d22018-07-17 10:46:29 -07001787 if (is_nonblocking)
1788 {
Florin Coras070453d2018-08-24 17:04:27 -07001789 return VPPCOM_EWOULDBLOCK;
Florin Coras54693d22018-07-17 10:46:29 -07001790 }
Florin Coras60f1fc12018-08-16 14:57:31 -07001791 while (svm_fifo_is_full (tx_fifo))
Florin Coras54693d22018-07-17 10:46:29 -07001792 {
Florin Coras0e88e852018-09-17 22:09:02 -07001793 svm_fifo_set_want_tx_evt (tx_fifo, 1);
Florin Coras99368312018-08-02 10:45:44 -07001794 svm_msg_q_lock (mq);
Florin Corasaa27eb92018-10-13 12:20:01 -07001795 if (svm_msg_q_is_empty (mq))
1796 svm_msg_q_wait (mq);
Florin Coras0e88e852018-09-17 22:09:02 -07001797
Florin Coras54693d22018-07-17 10:46:29 -07001798 svm_msg_q_sub_w_lock (mq, &msg);
1799 e = svm_msg_q_msg_data (mq, &msg);
Florin Coras99368312018-08-02 10:45:44 -07001800 svm_msg_q_unlock (mq);
1801
Florin Coras0e88e852018-09-17 22:09:02 -07001802 if (!vcl_is_tx_evt_for_session (e, s->session_index, is_ct))
Florin Coras86f04502018-09-12 16:08:01 -07001803 vcl_handle_mq_event (wrk, e);
Florin Coras54693d22018-07-17 10:46:29 -07001804 svm_msg_q_free_msg (mq, &msg);
Florin Coras54693d22018-07-17 10:46:29 -07001805 }
Dave Wallace543852a2017-08-03 02:11:34 -04001806 }
Dave Wallace543852a2017-08-03 02:11:34 -04001807
Florin Coras3c7d4f92018-12-14 11:28:43 -08001808 if (PREDICT_FALSE (!(s->session_state & STATE_OPEN)))
1809 return VPPCOM_ECONNRESET;
1810
Florin Coras460dce62018-07-27 05:45:06 -07001811 ASSERT (FIFO_EVENT_APP_TX + 1 == SESSION_IO_EVT_CT_TX);
1812 et = FIFO_EVENT_APP_TX + vcl_session_is_ct (s);
Florin Coras42ceddb2018-12-12 10:56:01 -08001813 if (is_flush && !vcl_session_is_ct (s))
1814 et = SESSION_IO_EVT_TX_FLUSH;
1815
Florin Coras460dce62018-07-27 05:45:06 -07001816 if (s->is_dgram)
1817 n_write = app_send_dgram_raw (tx_fifo, &s->transport,
1818 s->vpp_evt_q, buf, n, et, SVM_Q_WAIT);
1819 else
1820 n_write = app_send_stream_raw (tx_fifo, s->vpp_evt_q, buf, n, et,
1821 SVM_Q_WAIT);
Keith Burns (alagalah)410bcca2018-03-23 13:42:49 -07001822
Florin Coras460dce62018-07-27 05:45:06 -07001823 ASSERT (n_write > 0);
Dave Wallace543852a2017-08-03 02:11:34 -04001824
Florin Coras0e88e852018-09-17 22:09:02 -07001825 VDBG (2, "VCL<%d>: vpp handle 0x%llx, sid %u: wrote %d bytes", getpid (),
1826 s->vpp_handle, session_handle, n_write);
1827
Florin Coras54693d22018-07-17 10:46:29 -07001828 return n_write;
Dave Wallace543852a2017-08-03 02:11:34 -04001829}
1830
Florin Coras42ceddb2018-12-12 10:56:01 -08001831int
1832vppcom_session_write (uint32_t session_handle, void *buf, size_t n)
1833{
1834 return vppcom_session_write_inline (session_handle, buf, n,
1835 0 /* is_flush */ );
1836}
1837
Florin Coras99368312018-08-02 10:45:44 -07001838static vcl_session_t *
Florin Coras134a9962018-08-28 11:32:04 -07001839vcl_ct_session_get_from_fifo (vcl_worker_t * wrk, svm_fifo_t * f, u8 type)
Florin Coras99368312018-08-02 10:45:44 -07001840{
1841 vcl_session_t *s;
Florin Coras134a9962018-08-28 11:32:04 -07001842 s = vcl_session_get (wrk, f->client_session_index);
Florin Coras99368312018-08-02 10:45:44 -07001843 if (s)
1844 {
1845 /* rx fifo */
1846 if (type == 0 && s->rx_fifo == f)
1847 return s;
1848 /* tx fifo */
1849 if (type == 1 && s->tx_fifo == f)
1850 return s;
1851 }
Florin Coras134a9962018-08-28 11:32:04 -07001852 s = vcl_session_get (wrk, f->master_session_index);
Florin Coras99368312018-08-02 10:45:44 -07001853 if (s)
1854 {
1855 if (type == 0 && s->rx_fifo == f)
1856 return s;
1857 if (type == 1 && s->tx_fifo == f)
1858 return s;
1859 }
1860 return 0;
1861}
1862
Dave Wallace543852a2017-08-03 02:11:34 -04001863static inline int
Florin Coras134a9962018-08-28 11:32:04 -07001864vppcom_session_write_ready (vcl_session_t * session)
Dave Wallace543852a2017-08-03 02:11:34 -04001865{
Dave Wallace543852a2017-08-03 02:11:34 -04001866 /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
Dave Wallace4878cbe2017-11-21 03:45:09 -05001867 if (PREDICT_FALSE (session->is_vep))
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001868 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001869 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Dave Wallaceee45d412017-11-24 21:44:06 -05001870 "cannot write to an epoll session!",
Florin Coras134a9962018-08-28 11:32:04 -07001871 getpid (), session->vpp_handle, session->session_index);
Florin Coras54693d22018-07-17 10:46:29 -07001872 return VPPCOM_EBADFD;
Dave Wallace9c4b5b22017-10-18 21:15:48 -04001873 }
1874
Florin Coras7e12d942018-06-27 14:32:43 -07001875 if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
Dave Wallace33e002b2017-09-06 01:20:02 -04001876 {
Dave Wallace048b1d62018-01-03 22:24:41 -05001877 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Dave Wallaceee45d412017-11-24 21:44:06 -05001878 "cannot write to a listen session!",
Florin Coras134a9962018-08-28 11:32:04 -07001879 getpid (), session->vpp_handle, session->session_index);
Florin Coras54693d22018-07-17 10:46:29 -07001880 return VPPCOM_EBADFD;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001881 }
1882
Florin Coras54693d22018-07-17 10:46:29 -07001883 if (PREDICT_FALSE (!(session->session_state & STATE_OPEN)))
Dave Wallace4878cbe2017-11-21 03:45:09 -05001884 {
Florin Coras7e12d942018-06-27 14:32:43 -07001885 session_state_t state = session->session_state;
Florin Coras54693d22018-07-17 10:46:29 -07001886 int rv;
Dave Wallace4878cbe2017-11-21 03:45:09 -05001887
Keith Burns (alagalah)56a0d062018-02-15 07:52:50 -08001888 rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
Dave Wallace048b1d62018-01-03 22:24:41 -05001889 clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08001890 "session is not open! state 0x%x (%s), "
Dave Wallaceee45d412017-11-24 21:44:06 -05001891 "returning %d (%s)", getpid (), session->vpp_handle,
Florin Coras134a9962018-08-28 11:32:04 -07001892 session->session_index,
Dave Wallace4878cbe2017-11-21 03:45:09 -05001893 state, vppcom_session_state_str (state),
1894 rv, vppcom_retval_str (rv));
Florin Coras54693d22018-07-17 10:46:29 -07001895 return rv;
Dave Wallace33e002b2017-09-06 01:20:02 -04001896 }
1897
Florin Coras0d427d82018-06-27 03:24:07 -07001898 VDBG (3, "VCL<%d>: vpp handle 0x%llx, sid %u: peek %s (%p), ready = %d",
Florin Coras134a9962018-08-28 11:32:04 -07001899 getpid (), session->vpp_handle, session->session_index,
1900 session->tx_fifo, svm_fifo_max_enqueue (session->tx_fifo));
Dave Wallacef7f809c2017-10-03 01:48:42 -04001901
Florin Coras54693d22018-07-17 10:46:29 -07001902 return svm_fifo_max_enqueue (session->tx_fifo);
1903}
1904
Florin Coras99368312018-08-02 10:45:44 -07001905static inline int
Florin Coras134a9962018-08-28 11:32:04 -07001906vcl_mq_dequeue_batch (vcl_worker_t * wrk, svm_msg_q_t * mq)
Florin Coras99368312018-08-02 10:45:44 -07001907{
1908 svm_msg_q_msg_t *msg;
1909 u32 n_msgs;
1910 int i;
1911
1912 n_msgs = svm_msg_q_size (mq);
1913 for (i = 0; i < n_msgs; i++)
1914 {
Florin Coras134a9962018-08-28 11:32:04 -07001915 vec_add2 (wrk->mq_msg_vector, msg, 1);
Florin Coras99368312018-08-02 10:45:44 -07001916 svm_msg_q_sub_w_lock (mq, msg);
1917 }
1918 return n_msgs;
1919}
1920
Florin Coras6d4bb422018-09-04 22:07:27 -07001921#define vcl_fifo_rx_evt_valid_or_break(_fifo) \
1922if (PREDICT_FALSE (svm_fifo_is_empty (_fifo))) \
1923 { \
1924 svm_fifo_unset_event (_fifo); \
1925 if (svm_fifo_is_empty (_fifo)) \
Florin Coras41c9e042018-09-11 00:10:41 -07001926 break; \
Florin Coras6d4bb422018-09-04 22:07:27 -07001927 } \
1928
Florin Coras86f04502018-09-12 16:08:01 -07001929static void
1930vcl_select_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
1931 unsigned long n_bits, unsigned long *read_map,
1932 unsigned long *write_map,
1933 unsigned long *except_map, u32 * bits_set)
Florin Coras54693d22018-07-17 10:46:29 -07001934{
1935 session_disconnected_msg_t *disconnected_msg;
Florin Coras99368312018-08-02 10:45:44 -07001936 session_connected_msg_t *connected_msg;
Florin Coras54693d22018-07-17 10:46:29 -07001937 vcl_session_t *session;
Florin Coras86f04502018-09-12 16:08:01 -07001938 u32 sid;
1939
1940 switch (e->event_type)
1941 {
1942 case FIFO_EVENT_APP_RX:
1943 vcl_fifo_rx_evt_valid_or_break (e->fifo);
1944 sid = e->fifo->client_session_index;
1945 session = vcl_session_get (wrk, sid);
1946 if (!session)
1947 break;
1948 if (sid < n_bits && read_map)
1949 {
1950 clib_bitmap_set_no_check (read_map, sid, 1);
1951 *bits_set += 1;
1952 }
1953 break;
1954 case FIFO_EVENT_APP_TX:
1955 sid = e->fifo->client_session_index;
1956 session = vcl_session_get (wrk, sid);
1957 if (!session)
1958 break;
1959 if (sid < n_bits && write_map)
1960 {
1961 clib_bitmap_set_no_check (write_map, sid, 1);
1962 *bits_set += 1;
1963 }
1964 break;
1965 case SESSION_IO_EVT_CT_TX:
1966 vcl_fifo_rx_evt_valid_or_break (e->fifo);
1967 session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 0);
1968 if (!session)
1969 break;
1970 sid = session->session_index;
1971 if (sid < n_bits && read_map)
1972 {
1973 clib_bitmap_set_no_check (read_map, sid, 1);
1974 *bits_set += 1;
1975 }
1976 break;
1977 case SESSION_IO_EVT_CT_RX:
1978 session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 1);
1979 if (!session)
1980 break;
1981 sid = session->session_index;
1982 if (sid < n_bits && write_map)
1983 {
1984 clib_bitmap_set_no_check (write_map, sid, 1);
1985 *bits_set += 1;
1986 }
1987 break;
1988 case SESSION_CTRL_EVT_ACCEPTED:
Florin Coras3c7d4f92018-12-14 11:28:43 -08001989 session = vcl_session_accepted (wrk,
1990 (session_accepted_msg_t *) e->data);
Florin Coras86f04502018-09-12 16:08:01 -07001991 if (!session)
Florin Coras3c7d4f92018-12-14 11:28:43 -08001992 break;
Florin Coras86f04502018-09-12 16:08:01 -07001993 sid = session->session_index;
1994 if (sid < n_bits && read_map)
1995 {
1996 clib_bitmap_set_no_check (read_map, sid, 1);
1997 *bits_set += 1;
1998 }
1999 break;
2000 case SESSION_CTRL_EVT_CONNECTED:
2001 connected_msg = (session_connected_msg_t *) e->data;
2002 vcl_session_connected_handler (wrk, connected_msg);
2003 break;
2004 case SESSION_CTRL_EVT_DISCONNECTED:
2005 disconnected_msg = (session_disconnected_msg_t *) e->data;
Florin Coras3c7d4f92018-12-14 11:28:43 -08002006 session = vcl_session_disconnected_handler (wrk, disconnected_msg);
2007 if (!session)
2008 break;
2009 sid = session->session_index;
Florin Coras86f04502018-09-12 16:08:01 -07002010 if (sid < n_bits && except_map)
2011 {
2012 clib_bitmap_set_no_check (except_map, sid, 1);
2013 *bits_set += 1;
2014 }
2015 break;
2016 case SESSION_CTRL_EVT_RESET:
2017 sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
2018 if (sid < n_bits && except_map)
2019 {
2020 clib_bitmap_set_no_check (except_map, sid, 1);
2021 *bits_set += 1;
2022 }
2023 break;
2024 default:
2025 clib_warning ("unhandled: %u", e->event_type);
2026 break;
2027 }
2028}
2029
2030static int
2031vcl_select_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
2032 unsigned long n_bits, unsigned long *read_map,
2033 unsigned long *write_map, unsigned long *except_map,
2034 double time_to_wait, u32 * bits_set)
2035{
Florin Coras99368312018-08-02 10:45:44 -07002036 svm_msg_q_msg_t *msg;
Florin Coras54693d22018-07-17 10:46:29 -07002037 session_event_t *e;
Florin Coras86f04502018-09-12 16:08:01 -07002038 u32 i;
Florin Coras54693d22018-07-17 10:46:29 -07002039
2040 svm_msg_q_lock (mq);
2041 if (svm_msg_q_is_empty (mq))
Dave Wallace4878cbe2017-11-21 03:45:09 -05002042 {
Florin Coras54693d22018-07-17 10:46:29 -07002043 if (*bits_set)
Dave Wallace4878cbe2017-11-21 03:45:09 -05002044 {
Florin Coras54693d22018-07-17 10:46:29 -07002045 svm_msg_q_unlock (mq);
2046 return 0;
2047 }
Dave Wallace4878cbe2017-11-21 03:45:09 -05002048
Florin Coras54693d22018-07-17 10:46:29 -07002049 if (!time_to_wait)
2050 {
2051 svm_msg_q_unlock (mq);
2052 return 0;
2053 }
2054 else if (time_to_wait < 0)
2055 {
2056 svm_msg_q_wait (mq);
2057 }
2058 else
2059 {
2060 if (svm_msg_q_timedwait (mq, time_to_wait))
2061 {
2062 svm_msg_q_unlock (mq);
2063 return 0;
2064 }
Dave Wallace4878cbe2017-11-21 03:45:09 -05002065 }
2066 }
Florin Coras134a9962018-08-28 11:32:04 -07002067 vcl_mq_dequeue_batch (wrk, mq);
Florin Coras54693d22018-07-17 10:46:29 -07002068 svm_msg_q_unlock (mq);
2069
Florin Coras134a9962018-08-28 11:32:04 -07002070 for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
Florin Coras54693d22018-07-17 10:46:29 -07002071 {
Florin Coras134a9962018-08-28 11:32:04 -07002072 msg = vec_elt_at_index (wrk->mq_msg_vector, i);
Florin Coras99368312018-08-02 10:45:44 -07002073 e = svm_msg_q_msg_data (mq, msg);
Florin Coras86f04502018-09-12 16:08:01 -07002074 vcl_select_handle_mq_event (wrk, e, n_bits, read_map, write_map,
2075 except_map, bits_set);
Florin Coras99368312018-08-02 10:45:44 -07002076 svm_msg_q_free_msg (mq, msg);
Florin Coras54693d22018-07-17 10:46:29 -07002077 }
Florin Coras134a9962018-08-28 11:32:04 -07002078 vec_reset_length (wrk->mq_msg_vector);
Florin Coras54693d22018-07-17 10:46:29 -07002079 return *bits_set;
Dave Wallace543852a2017-08-03 02:11:34 -04002080}
2081
Florin Coras99368312018-08-02 10:45:44 -07002082static int
Florin Coras134a9962018-08-28 11:32:04 -07002083vppcom_select_condvar (vcl_worker_t * wrk, unsigned long n_bits,
2084 unsigned long *read_map, unsigned long *write_map,
2085 unsigned long *except_map, double time_to_wait,
2086 u32 * bits_set)
Florin Coras99368312018-08-02 10:45:44 -07002087{
2088 double total_wait = 0, wait_slice;
2089 vcl_cut_through_registration_t *cr;
2090
2091 time_to_wait = (time_to_wait == -1) ? 10e9 : time_to_wait;
Florin Coras134a9962018-08-28 11:32:04 -07002092 wait_slice = wrk->cut_through_registrations ? 10e-6 : time_to_wait;
Florin Coras99368312018-08-02 10:45:44 -07002093 do
2094 {
Florin Coras134a9962018-08-28 11:32:04 -07002095 vcl_ct_registration_lock (wrk);
Florin Coras99368312018-08-02 10:45:44 -07002096 /* *INDENT-OFF* */
Florin Coras134a9962018-08-28 11:32:04 -07002097 pool_foreach (cr, wrk->cut_through_registrations, ({
2098 vcl_select_handle_mq (wrk, cr->mq, n_bits, read_map, write_map, except_map,
Florin Coras99368312018-08-02 10:45:44 -07002099 0, bits_set);
2100 }));
2101 /* *INDENT-ON* */
Florin Coras134a9962018-08-28 11:32:04 -07002102 vcl_ct_registration_unlock (wrk);
Florin Coras99368312018-08-02 10:45:44 -07002103
Florin Coras134a9962018-08-28 11:32:04 -07002104 vcl_select_handle_mq (wrk, wrk->app_event_queue, n_bits, read_map,
2105 write_map, except_map, time_to_wait, bits_set);
Florin Coras99368312018-08-02 10:45:44 -07002106 total_wait += wait_slice;
2107 if (*bits_set)
2108 return *bits_set;
2109 }
2110 while (total_wait < time_to_wait);
2111
2112 return 0;
2113}
2114
2115static int
Florin Coras134a9962018-08-28 11:32:04 -07002116vppcom_select_eventfd (vcl_worker_t * wrk, unsigned long n_bits,
2117 unsigned long *read_map, unsigned long *write_map,
2118 unsigned long *except_map, double time_to_wait,
2119 u32 * bits_set)
Florin Coras99368312018-08-02 10:45:44 -07002120{
2121 vcl_mq_evt_conn_t *mqc;
2122 int __clib_unused n_read;
2123 int n_mq_evts, i;
2124 u64 buf;
2125
Florin Coras134a9962018-08-28 11:32:04 -07002126 vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
2127 n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
2128 vec_len (wrk->mq_events), time_to_wait);
Florin Coras99368312018-08-02 10:45:44 -07002129 for (i = 0; i < n_mq_evts; i++)
2130 {
Florin Coras134a9962018-08-28 11:32:04 -07002131 mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
Florin Coras99368312018-08-02 10:45:44 -07002132 n_read = read (mqc->mq_fd, &buf, sizeof (buf));
Florin Coras134a9962018-08-28 11:32:04 -07002133 vcl_select_handle_mq (wrk, mqc->mq, n_bits, read_map, write_map,
Florin Coras99368312018-08-02 10:45:44 -07002134 except_map, 0, bits_set);
2135 }
2136
2137 return (n_mq_evts > 0 ? (int) *bits_set : 0);
2138}
2139
Dave Wallace543852a2017-08-03 02:11:34 -04002140int
2141vppcom_select (unsigned long n_bits, unsigned long *read_map,
2142 unsigned long *write_map, unsigned long *except_map,
2143 double time_to_wait)
2144{
Florin Coras54693d22018-07-17 10:46:29 -07002145 u32 sid, minbits = clib_max (n_bits, BITS (uword)), bits_set = 0;
Florin Coras134a9962018-08-28 11:32:04 -07002146 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07002147 vcl_session_t *session = 0;
Florin Coras86f04502018-09-12 16:08:01 -07002148 int rv, i;
Dave Wallace543852a2017-08-03 02:11:34 -04002149
2150 ASSERT (sizeof (clib_bitmap_t) == sizeof (long int));
2151
Dave Wallace7876d392017-10-19 03:53:57 -04002152 if (n_bits && read_map)
Dave Wallace543852a2017-08-03 02:11:34 -04002153 {
Florin Coras134a9962018-08-28 11:32:04 -07002154 clib_bitmap_validate (wrk->rd_bitmap, minbits);
Dave Barach178cf492018-11-13 16:34:13 -05002155 clib_memcpy_fast (wrk->rd_bitmap, read_map,
2156 vec_len (wrk->rd_bitmap) * sizeof (clib_bitmap_t));
Florin Coras134a9962018-08-28 11:32:04 -07002157 memset (read_map, 0, vec_len (wrk->rd_bitmap) * sizeof (clib_bitmap_t));
Dave Wallace543852a2017-08-03 02:11:34 -04002158 }
Dave Wallace7876d392017-10-19 03:53:57 -04002159 if (n_bits && write_map)
Dave Wallace543852a2017-08-03 02:11:34 -04002160 {
Florin Coras134a9962018-08-28 11:32:04 -07002161 clib_bitmap_validate (wrk->wr_bitmap, minbits);
Dave Barach178cf492018-11-13 16:34:13 -05002162 clib_memcpy_fast (wrk->wr_bitmap, write_map,
2163 vec_len (wrk->wr_bitmap) * sizeof (clib_bitmap_t));
Dave Wallace048b1d62018-01-03 22:24:41 -05002164 memset (write_map, 0,
Florin Coras134a9962018-08-28 11:32:04 -07002165 vec_len (wrk->wr_bitmap) * sizeof (clib_bitmap_t));
Dave Wallace543852a2017-08-03 02:11:34 -04002166 }
Dave Wallace7876d392017-10-19 03:53:57 -04002167 if (n_bits && except_map)
Dave Wallace543852a2017-08-03 02:11:34 -04002168 {
Florin Coras134a9962018-08-28 11:32:04 -07002169 clib_bitmap_validate (wrk->ex_bitmap, minbits);
Dave Barach178cf492018-11-13 16:34:13 -05002170 clib_memcpy_fast (wrk->ex_bitmap, except_map,
2171 vec_len (wrk->ex_bitmap) * sizeof (clib_bitmap_t));
Dave Wallace048b1d62018-01-03 22:24:41 -05002172 memset (except_map, 0,
Florin Coras134a9962018-08-28 11:32:04 -07002173 vec_len (wrk->ex_bitmap) * sizeof (clib_bitmap_t));
Dave Wallace543852a2017-08-03 02:11:34 -04002174 }
2175
Florin Coras54693d22018-07-17 10:46:29 -07002176 if (!n_bits)
2177 return 0;
2178
2179 if (!write_map)
2180 goto check_rd;
2181
2182 /* *INDENT-OFF* */
Florin Coras134a9962018-08-28 11:32:04 -07002183 clib_bitmap_foreach (sid, wrk->wr_bitmap, ({
2184 if (!(session = vcl_session_get (wrk, sid)))
Florin Coras54693d22018-07-17 10:46:29 -07002185 {
Florin Coras47c40e22018-11-26 17:01:36 -08002186 if (except_map && sid < minbits)
2187 clib_bitmap_set_no_check (except_map, sid, 1);
2188 continue;
Florin Coras54693d22018-07-17 10:46:29 -07002189 }
2190
2191 rv = svm_fifo_is_full (session->tx_fifo);
Florin Coras54693d22018-07-17 10:46:29 -07002192 if (!rv)
2193 {
2194 clib_bitmap_set_no_check (write_map, sid, 1);
2195 bits_set++;
2196 }
2197 }));
2198
2199check_rd:
2200 if (!read_map)
2201 goto check_mq;
Florin Coras99368312018-08-02 10:45:44 -07002202
Florin Coras134a9962018-08-28 11:32:04 -07002203 clib_bitmap_foreach (sid, wrk->rd_bitmap, ({
2204 if (!(session = vcl_session_get (wrk, sid)))
Florin Coras54693d22018-07-17 10:46:29 -07002205 {
Florin Coras47c40e22018-11-26 17:01:36 -08002206 if (except_map && sid < minbits)
2207 clib_bitmap_set_no_check (except_map, sid, 1);
2208 continue;
Florin Coras54693d22018-07-17 10:46:29 -07002209 }
2210
2211 rv = vppcom_session_read_ready (session);
Florin Coras54693d22018-07-17 10:46:29 -07002212 if (rv)
2213 {
2214 clib_bitmap_set_no_check (read_map, sid, 1);
2215 bits_set++;
2216 }
2217 }));
2218 /* *INDENT-ON* */
2219
2220check_mq:
Dave Wallace543852a2017-08-03 02:11:34 -04002221
Florin Coras86f04502018-09-12 16:08:01 -07002222 for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
2223 {
2224 vcl_select_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i], n_bits,
2225 read_map, write_map, except_map, &bits_set);
2226 }
2227 vec_reset_length (wrk->unhandled_evts_vector);
2228
Florin Coras99368312018-08-02 10:45:44 -07002229 if (vcm->cfg.use_mq_eventfd)
Florin Coras134a9962018-08-28 11:32:04 -07002230 vppcom_select_eventfd (wrk, n_bits, read_map, write_map, except_map,
Florin Coras99368312018-08-02 10:45:44 -07002231 time_to_wait, &bits_set);
2232 else
Florin Coras134a9962018-08-28 11:32:04 -07002233 vppcom_select_condvar (wrk, n_bits, read_map, write_map, except_map,
Florin Coras99368312018-08-02 10:45:44 -07002234 time_to_wait, &bits_set);
Florin Coras54693d22018-07-17 10:46:29 -07002235
Dave Wallace543852a2017-08-03 02:11:34 -04002236 return (bits_set);
2237}
2238
Dave Wallacef7f809c2017-10-03 01:48:42 -04002239static inline void
Florin Coras134a9962018-08-28 11:32:04 -07002240vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_idx)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002241{
Florin Coras7e12d942018-06-27 14:32:43 -07002242 vcl_session_t *session;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002243 vppcom_epoll_t *vep;
Dave Wallace498b3a52017-11-09 13:00:34 -05002244 u32 sid = vep_idx;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002245
Dave Wallace498b3a52017-11-09 13:00:34 -05002246 if (VPPCOM_DEBUG <= 1)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002247 return;
2248
2249 /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
Florin Coras134a9962018-08-28 11:32:04 -07002250 session = vcl_session_get (wrk, vep_idx);
Florin Coras070453d2018-08-24 17:04:27 -07002251 if (PREDICT_FALSE (!session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002252 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002253 clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!",
2254 getpid (), vep_idx);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002255 goto done;
2256 }
2257 if (PREDICT_FALSE (!session->is_vep))
2258 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002259 clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
2260 getpid (), vep_idx);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002261 goto done;
2262 }
Dave Wallace4878cbe2017-11-21 03:45:09 -05002263 vep = &session->vep;
Dave Wallace048b1d62018-01-03 22:24:41 -05002264 clib_warning ("VCL<%d>: vep_idx (%u): Dumping epoll chain\n"
Dave Wallace498b3a52017-11-09 13:00:34 -05002265 "{\n"
2266 " is_vep = %u\n"
2267 " is_vep_session = %u\n"
Dave Wallace4878cbe2017-11-21 03:45:09 -05002268 " next_sid = 0x%x (%u)\n"
Dave Wallace498b3a52017-11-09 13:00:34 -05002269 " wait_cont_idx = 0x%x (%u)\n"
Dave Wallace4878cbe2017-11-21 03:45:09 -05002270 "}\n", getpid (), vep_idx,
2271 session->is_vep, session->is_vep_session,
Florin Coras134a9962018-08-28 11:32:04 -07002272 vep->next_sh, vep->next_sh,
Dave Wallace498b3a52017-11-09 13:00:34 -05002273 session->wait_cont_idx, session->wait_cont_idx);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002274
Florin Coras134a9962018-08-28 11:32:04 -07002275 for (sid = vep->next_sh; sid != ~0; sid = vep->next_sh)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002276 {
Florin Coras134a9962018-08-28 11:32:04 -07002277 session = vcl_session_get (wrk, sid);
Florin Coras070453d2018-08-24 17:04:27 -07002278 if (PREDICT_FALSE (!session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002279 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002280 clib_warning ("VCL<%d>: ERROR: Invalid sid (%u)!", getpid (), sid);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002281 goto done;
2282 }
2283 if (PREDICT_FALSE (session->is_vep))
Dave Wallace048b1d62018-01-03 22:24:41 -05002284 clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
2285 getpid (), vep_idx);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002286 else if (PREDICT_FALSE (!session->is_vep_session))
2287 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002288 clib_warning ("VCL<%d>: ERROR: session (%u) "
2289 "is not a vep session!", getpid (), sid);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002290 goto done;
2291 }
2292 vep = &session->vep;
Florin Coras134a9962018-08-28 11:32:04 -07002293 if (PREDICT_FALSE (vep->vep_sh != vep_idx))
Dave Wallace048b1d62018-01-03 22:24:41 -05002294 clib_warning ("VCL<%d>: ERROR: session (%u) vep_idx (%u) != "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002295 "vep_idx (%u)!", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07002296 sid, session->vep.vep_sh, vep_idx);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002297 if (session->is_vep_session)
2298 {
2299 clib_warning ("vep_idx[%u]: sid 0x%x (%u)\n"
2300 "{\n"
2301 " next_sid = 0x%x (%u)\n"
2302 " prev_sid = 0x%x (%u)\n"
2303 " vep_idx = 0x%x (%u)\n"
2304 " ev.events = 0x%x\n"
2305 " ev.data.u64 = 0x%llx\n"
2306 " et_mask = 0x%x\n"
2307 "}\n",
2308 vep_idx, sid, sid,
Florin Coras134a9962018-08-28 11:32:04 -07002309 vep->next_sh, vep->next_sh,
2310 vep->prev_sh, vep->prev_sh,
2311 vep->vep_sh, vep->vep_sh,
Dave Wallace4878cbe2017-11-21 03:45:09 -05002312 vep->ev.events, vep->ev.data.u64, vep->et_mask);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002313 }
2314 }
Dave Wallacef7f809c2017-10-03 01:48:42 -04002315
2316done:
Dave Wallace048b1d62018-01-03 22:24:41 -05002317 clib_warning ("VCL<%d>: vep_idx (%u): Dump complete!\n",
2318 getpid (), vep_idx);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002319}
2320
2321int
2322vppcom_epoll_create (void)
2323{
Florin Coras134a9962018-08-28 11:32:04 -07002324 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07002325 vcl_session_t *vep_session;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002326
Florin Coras134a9962018-08-28 11:32:04 -07002327 vep_session = vcl_session_alloc (wrk);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002328
2329 vep_session->is_vep = 1;
Florin Coras134a9962018-08-28 11:32:04 -07002330 vep_session->vep.vep_sh = ~0;
2331 vep_session->vep.next_sh = ~0;
2332 vep_session->vep.prev_sh = ~0;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002333 vep_session->wait_cont_idx = ~0;
Dave Wallace4878cbe2017-11-21 03:45:09 -05002334 vep_session->vpp_handle = ~0;
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08002335
Florin Coras134a9962018-08-28 11:32:04 -07002336 vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_sh);
Florin Coras0d427d82018-06-27 03:24:07 -07002337 VDBG (0, "VCL<%d>: Created vep_idx %u / sid %u!",
Florin Coras134a9962018-08-28 11:32:04 -07002338 getpid (), vep_session->session_index, vep_session->session_index);
Keith Burns (alagalah)09b27842018-01-05 14:39:59 -08002339
Florin Corasab2f6db2018-08-31 14:31:41 -07002340 return vcl_session_handle (vep_session);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002341}
2342
2343int
Florin Coras134a9962018-08-28 11:32:04 -07002344vppcom_epoll_ctl (uint32_t vep_handle, int op, uint32_t session_handle,
Dave Wallacef7f809c2017-10-03 01:48:42 -04002345 struct epoll_event *event)
2346{
Florin Coras134a9962018-08-28 11:32:04 -07002347 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07002348 vcl_session_t *vep_session;
2349 vcl_session_t *session;
Florin Coras070453d2018-08-24 17:04:27 -07002350 int rv = VPPCOM_OK;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002351
Florin Coras134a9962018-08-28 11:32:04 -07002352 if (vep_handle == session_handle)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002353 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002354 clib_warning ("VCL<%d>: ERROR: vep_idx == session_index (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002355 getpid (), vep_handle);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002356 return VPPCOM_EINVAL;
2357 }
2358
Florin Coras134a9962018-08-28 11:32:04 -07002359 vep_session = vcl_session_get_w_handle (wrk, vep_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002360 if (PREDICT_FALSE (!vep_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002361 {
Florin Coras134a9962018-08-28 11:32:04 -07002362 clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!", vep_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002363 return VPPCOM_EBADFD;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002364 }
2365 if (PREDICT_FALSE (!vep_session->is_vep))
2366 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002367 clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
Florin Coras134a9962018-08-28 11:32:04 -07002368 getpid (), vep_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002369 return VPPCOM_EINVAL;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002370 }
2371
Florin Coras134a9962018-08-28 11:32:04 -07002372 ASSERT (vep_session->vep.vep_sh == ~0);
2373 ASSERT (vep_session->vep.prev_sh == ~0);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002374
Florin Coras134a9962018-08-28 11:32:04 -07002375 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002376 if (PREDICT_FALSE (!session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002377 {
Florin Coras134a9962018-08-28 11:32:04 -07002378 VDBG (0, "VCL<%d>: ERROR: Invalid session_handle (%u)!",
2379 getpid (), session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002380 return VPPCOM_EBADFD;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002381 }
2382 if (PREDICT_FALSE (session->is_vep))
2383 {
Florin Coras134a9962018-08-28 11:32:04 -07002384 clib_warning ("ERROR: session_handle (%u) is a vep!", vep_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002385 return VPPCOM_EINVAL;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002386 }
2387
2388 switch (op)
2389 {
2390 case EPOLL_CTL_ADD:
2391 if (PREDICT_FALSE (!event))
2392 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002393 clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: NULL pointer to "
Dave Wallace2e005bb2017-11-07 01:21:39 -05002394 "epoll_event structure!", getpid ());
Florin Coras070453d2018-08-24 17:04:27 -07002395 return VPPCOM_EINVAL;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002396 }
Florin Coras134a9962018-08-28 11:32:04 -07002397 if (vep_session->vep.next_sh != ~0)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002398 {
Florin Coras7e12d942018-06-27 14:32:43 -07002399 vcl_session_t *next_session;
Florin Corasab2f6db2018-08-31 14:31:41 -07002400 next_session = vcl_session_get_w_handle (wrk,
2401 vep_session->vep.next_sh);
Florin Coras070453d2018-08-24 17:04:27 -07002402 if (PREDICT_FALSE (!next_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002403 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002404 clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: Invalid "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002405 "vep.next_sid (%u) on vep_idx (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002406 getpid (), vep_session->vep.next_sh, vep_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002407 return VPPCOM_EBADFD;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002408 }
Florin Coras134a9962018-08-28 11:32:04 -07002409 ASSERT (next_session->vep.prev_sh == vep_handle);
2410 next_session->vep.prev_sh = session_handle;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002411 }
Florin Coras134a9962018-08-28 11:32:04 -07002412 session->vep.next_sh = vep_session->vep.next_sh;
2413 session->vep.prev_sh = vep_handle;
2414 session->vep.vep_sh = vep_handle;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002415 session->vep.et_mask = VEP_DEFAULT_ET_MASK;
2416 session->vep.ev = *event;
Dave Wallace4878cbe2017-11-21 03:45:09 -05002417 session->is_vep = 0;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002418 session->is_vep_session = 1;
Florin Coras134a9962018-08-28 11:32:04 -07002419 vep_session->vep.next_sh = session_handle;
Keith Burns (alagalah)3cf2d642018-02-23 10:17:01 -08002420
Florin Coras070453d2018-08-24 17:04:27 -07002421 VDBG (1, "VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, sid %u, events 0x%x, "
Florin Coras134a9962018-08-28 11:32:04 -07002422 "data 0x%llx!", getpid (), vep_handle, session_handle,
2423 event->events, event->data.u64);
Florin Coras0d427d82018-06-27 03:24:07 -07002424 vcl_evt (VCL_EVT_EPOLL_CTLADD, session, event->events, event->data.u64);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002425 break;
2426
2427 case EPOLL_CTL_MOD:
2428 if (PREDICT_FALSE (!event))
2429 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002430 clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_MOD: NULL pointer to "
Dave Wallace2e005bb2017-11-07 01:21:39 -05002431 "epoll_event structure!", getpid ());
Dave Wallacef7f809c2017-10-03 01:48:42 -04002432 rv = VPPCOM_EINVAL;
2433 goto done;
2434 }
Dave Wallace4878cbe2017-11-21 03:45:09 -05002435 else if (PREDICT_FALSE (!session->is_vep_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002436 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002437 clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
Florin Coras134a9962018-08-28 11:32:04 -07002438 "not a vep session!", getpid (), session_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002439 rv = VPPCOM_EINVAL;
2440 goto done;
2441 }
Florin Coras134a9962018-08-28 11:32:04 -07002442 else if (PREDICT_FALSE (session->vep.vep_sh != vep_handle))
Dave Wallace4878cbe2017-11-21 03:45:09 -05002443 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002444 clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002445 "vep_idx (%u) != vep_idx (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002446 getpid (), session_handle,
2447 session->vep.vep_sh, vep_handle);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002448 rv = VPPCOM_EINVAL;
2449 goto done;
2450 }
2451 session->vep.et_mask = VEP_DEFAULT_ET_MASK;
2452 session->vep.ev = *event;
Florin Coras0d427d82018-06-27 03:24:07 -07002453 VDBG (1, "VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
Florin Coras134a9962018-08-28 11:32:04 -07002454 " data 0x%llx!", getpid (), vep_handle, session_handle,
2455 event->events, event->data.u64);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002456 break;
2457
2458 case EPOLL_CTL_DEL:
Dave Wallace4878cbe2017-11-21 03:45:09 -05002459 if (PREDICT_FALSE (!session->is_vep_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002460 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002461 clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
Florin Coras134a9962018-08-28 11:32:04 -07002462 "not a vep session!", getpid (), session_handle);
Dave Wallace4878cbe2017-11-21 03:45:09 -05002463 rv = VPPCOM_EINVAL;
2464 goto done;
2465 }
Florin Coras134a9962018-08-28 11:32:04 -07002466 else if (PREDICT_FALSE (session->vep.vep_sh != vep_handle))
Dave Wallace4878cbe2017-11-21 03:45:09 -05002467 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002468 clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002469 "vep_idx (%u) != vep_idx (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002470 getpid (), session_handle,
2471 session->vep.vep_sh, vep_handle);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002472 rv = VPPCOM_EINVAL;
2473 goto done;
2474 }
2475
2476 vep_session->wait_cont_idx =
Florin Coras134a9962018-08-28 11:32:04 -07002477 (vep_session->wait_cont_idx == session_handle) ?
2478 session->vep.next_sh : vep_session->wait_cont_idx;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002479
Florin Coras134a9962018-08-28 11:32:04 -07002480 if (session->vep.prev_sh == vep_handle)
2481 vep_session->vep.next_sh = session->vep.next_sh;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002482 else
2483 {
Florin Coras7e12d942018-06-27 14:32:43 -07002484 vcl_session_t *prev_session;
Florin Corasab2f6db2018-08-31 14:31:41 -07002485 prev_session = vcl_session_get_w_handle (wrk, session->vep.prev_sh);
Florin Coras070453d2018-08-24 17:04:27 -07002486 if (PREDICT_FALSE (!prev_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002487 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002488 clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002489 "vep.prev_sid (%u) on sid (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002490 getpid (), session->vep.prev_sh, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002491 return VPPCOM_EBADFD;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002492 }
Florin Coras134a9962018-08-28 11:32:04 -07002493 ASSERT (prev_session->vep.next_sh == session_handle);
2494 prev_session->vep.next_sh = session->vep.next_sh;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002495 }
Florin Coras134a9962018-08-28 11:32:04 -07002496 if (session->vep.next_sh != ~0)
Dave Wallacef7f809c2017-10-03 01:48:42 -04002497 {
Florin Coras7e12d942018-06-27 14:32:43 -07002498 vcl_session_t *next_session;
Florin Corasab2f6db2018-08-31 14:31:41 -07002499 next_session = vcl_session_get_w_handle (wrk, session->vep.next_sh);
Florin Coras070453d2018-08-24 17:04:27 -07002500 if (PREDICT_FALSE (!next_session))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002501 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002502 clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
Dave Wallace4878cbe2017-11-21 03:45:09 -05002503 "vep.next_sid (%u) on sid (%u)!",
Florin Coras134a9962018-08-28 11:32:04 -07002504 getpid (), session->vep.next_sh, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002505 return VPPCOM_EBADFD;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002506 }
Florin Coras134a9962018-08-28 11:32:04 -07002507 ASSERT (next_session->vep.prev_sh == session_handle);
2508 next_session->vep.prev_sh = session->vep.prev_sh;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002509 }
2510
2511 memset (&session->vep, 0, sizeof (session->vep));
Florin Coras134a9962018-08-28 11:32:04 -07002512 session->vep.next_sh = ~0;
2513 session->vep.prev_sh = ~0;
2514 session->vep.vep_sh = ~0;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002515 session->is_vep_session = 0;
Florin Coras0d427d82018-06-27 03:24:07 -07002516 VDBG (1, "VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
Florin Coras134a9962018-08-28 11:32:04 -07002517 getpid (), vep_handle, session_handle);
2518 vcl_evt (VCL_EVT_EPOLL_CTLDEL, session, vep_sh);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002519 break;
2520
2521 default:
Dave Wallace048b1d62018-01-03 22:24:41 -05002522 clib_warning ("VCL<%d>: ERROR: Invalid operation (%d)!", getpid (), op);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002523 rv = VPPCOM_EINVAL;
2524 }
2525
Florin Coras134a9962018-08-28 11:32:04 -07002526 vep_verify_epoll_chain (wrk, vep_handle);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002527
2528done:
Dave Wallacef7f809c2017-10-03 01:48:42 -04002529 return rv;
2530}
2531
Florin Coras86f04502018-09-12 16:08:01 -07002532static inline void
2533vcl_epoll_wait_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
2534 struct epoll_event *events, u32 * num_ev)
Florin Coras54693d22018-07-17 10:46:29 -07002535{
2536 session_disconnected_msg_t *disconnected_msg;
2537 session_connected_msg_t *connected_msg;
Florin Coras99368312018-08-02 10:45:44 -07002538 u32 sid = ~0, session_events;
Florin Coras3c7d4f92018-12-14 11:28:43 -08002539 u64 session_evt_data = ~0;
Florin Coras54693d22018-07-17 10:46:29 -07002540 vcl_session_t *session;
Florin Coras86f04502018-09-12 16:08:01 -07002541 u8 add_event = 0;
2542
2543 switch (e->event_type)
2544 {
2545 case FIFO_EVENT_APP_RX:
2546 ASSERT (e->fifo->client_thread_index == vcl_get_worker_index ());
2547 vcl_fifo_rx_evt_valid_or_break (e->fifo);
2548 sid = e->fifo->client_session_index;
2549 session = vcl_session_get (wrk, sid);
2550 session_events = session->vep.ev.events;
Florin Corasaa27eb92018-10-13 12:20:01 -07002551 if (!(EPOLLIN & session->vep.ev.events) || session->has_rx_evt)
Florin Coras86f04502018-09-12 16:08:01 -07002552 break;
2553 add_event = 1;
2554 events[*num_ev].events |= EPOLLIN;
2555 session_evt_data = session->vep.ev.data.u64;
Florin Corasaa27eb92018-10-13 12:20:01 -07002556 session->has_rx_evt = 1;
Florin Coras86f04502018-09-12 16:08:01 -07002557 break;
2558 case FIFO_EVENT_APP_TX:
2559 sid = e->fifo->client_session_index;
2560 session = vcl_session_get (wrk, sid);
2561 session_events = session->vep.ev.events;
2562 if (!(EPOLLOUT & session_events))
2563 break;
2564 add_event = 1;
2565 events[*num_ev].events |= EPOLLOUT;
2566 session_evt_data = session->vep.ev.data.u64;
2567 break;
2568 case SESSION_IO_EVT_CT_TX:
2569 vcl_fifo_rx_evt_valid_or_break (e->fifo);
2570 session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 0);
2571 sid = session->session_index;
2572 session_events = session->vep.ev.events;
Florin Corasaa27eb92018-10-13 12:20:01 -07002573 if (!(EPOLLIN & session->vep.ev.events) || session->has_rx_evt)
Florin Coras86f04502018-09-12 16:08:01 -07002574 break;
2575 add_event = 1;
2576 events[*num_ev].events |= EPOLLIN;
2577 session_evt_data = session->vep.ev.data.u64;
Florin Corasaa27eb92018-10-13 12:20:01 -07002578 session->has_rx_evt = 1;
Florin Coras86f04502018-09-12 16:08:01 -07002579 break;
2580 case SESSION_IO_EVT_CT_RX:
2581 session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 1);
2582 sid = session->session_index;
2583 session_events = session->vep.ev.events;
2584 if (!(EPOLLOUT & session_events))
2585 break;
2586 add_event = 1;
2587 events[*num_ev].events |= EPOLLOUT;
2588 session_evt_data = session->vep.ev.data.u64;
2589 break;
2590 case SESSION_CTRL_EVT_ACCEPTED:
Florin Coras3c7d4f92018-12-14 11:28:43 -08002591 session = vcl_session_accepted (wrk,
2592 (session_accepted_msg_t *) e->data);
Florin Coras86f04502018-09-12 16:08:01 -07002593 if (!session)
Florin Coras3c7d4f92018-12-14 11:28:43 -08002594 break;
Florin Coras86f04502018-09-12 16:08:01 -07002595
Florin Coras86f04502018-09-12 16:08:01 -07002596 session_events = session->vep.ev.events;
2597 if (!(EPOLLIN & session_events))
2598 break;
2599
2600 add_event = 1;
2601 events[*num_ev].events |= EPOLLIN;
2602 session_evt_data = session->vep.ev.data.u64;
2603 break;
2604 case SESSION_CTRL_EVT_CONNECTED:
2605 connected_msg = (session_connected_msg_t *) e->data;
2606 vcl_session_connected_handler (wrk, connected_msg);
2607 /* Generate EPOLLOUT because there's no connected event */
2608 sid = vcl_session_index_from_vpp_handle (wrk, connected_msg->handle);
2609 session = vcl_session_get (wrk, sid);
2610 session_events = session->vep.ev.events;
2611 if (EPOLLOUT & session_events)
2612 {
2613 add_event = 1;
2614 events[*num_ev].events |= EPOLLOUT;
2615 session_evt_data = session->vep.ev.data.u64;
2616 }
2617 break;
2618 case SESSION_CTRL_EVT_DISCONNECTED:
2619 disconnected_msg = (session_disconnected_msg_t *) e->data;
Florin Coras3c7d4f92018-12-14 11:28:43 -08002620 session = vcl_session_disconnected_handler (wrk, disconnected_msg);
2621 if (!session)
Florin Coras86f04502018-09-12 16:08:01 -07002622 break;
2623 add_event = 1;
2624 events[*num_ev].events |= EPOLLHUP | EPOLLRDHUP;
2625 session_evt_data = session->vep.ev.data.u64;
2626 session_events = session->vep.ev.events;
2627 break;
2628 case SESSION_CTRL_EVT_RESET:
2629 sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
2630 if (!(session = vcl_session_get (wrk, sid)))
2631 break;
2632 add_event = 1;
2633 events[*num_ev].events |= EPOLLHUP | EPOLLRDHUP;
2634 session_evt_data = session->vep.ev.data.u64;
2635 session_events = session->vep.ev.events;
2636 break;
2637 default:
2638 VDBG (0, "unhandled: %u", e->event_type);
2639 break;
2640 }
2641
2642 if (add_event)
2643 {
2644 events[*num_ev].data.u64 = session_evt_data;
2645 if (EPOLLONESHOT & session_events)
2646 {
2647 session = vcl_session_get (wrk, sid);
2648 session->vep.ev.events = 0;
2649 }
2650 *num_ev += 1;
2651 }
2652}
2653
2654static int
2655vcl_epoll_wait_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
2656 struct epoll_event *events, u32 maxevents,
2657 double wait_for_time, u32 * num_ev)
2658{
Florin Coras99368312018-08-02 10:45:44 -07002659 svm_msg_q_msg_t *msg;
Florin Coras54693d22018-07-17 10:46:29 -07002660 session_event_t *e;
Florin Coras54693d22018-07-17 10:46:29 -07002661 int i;
2662
Florin Coras539663c2018-09-28 14:59:37 -07002663 if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
2664 goto handle_dequeued;
2665
Florin Coras54693d22018-07-17 10:46:29 -07002666 svm_msg_q_lock (mq);
2667 if (svm_msg_q_is_empty (mq))
2668 {
2669 if (!wait_for_time)
2670 {
2671 svm_msg_q_unlock (mq);
2672 return 0;
2673 }
2674 else if (wait_for_time < 0)
2675 {
2676 svm_msg_q_wait (mq);
2677 }
2678 else
2679 {
Florin Coras60f1fc12018-08-16 14:57:31 -07002680 if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
Florin Coras54693d22018-07-17 10:46:29 -07002681 {
2682 svm_msg_q_unlock (mq);
2683 return 0;
2684 }
2685 }
2686 }
Florin Coras134a9962018-08-28 11:32:04 -07002687 vcl_mq_dequeue_batch (wrk, mq);
Florin Coras54693d22018-07-17 10:46:29 -07002688 svm_msg_q_unlock (mq);
2689
Florin Coras539663c2018-09-28 14:59:37 -07002690handle_dequeued:
Florin Coras134a9962018-08-28 11:32:04 -07002691 for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
Florin Coras54693d22018-07-17 10:46:29 -07002692 {
Florin Coras134a9962018-08-28 11:32:04 -07002693 msg = vec_elt_at_index (wrk->mq_msg_vector, i);
Florin Coras99368312018-08-02 10:45:44 -07002694 e = svm_msg_q_msg_data (mq, msg);
Florin Corasaa27eb92018-10-13 12:20:01 -07002695 if (*num_ev < maxevents)
2696 vcl_epoll_wait_handle_mq_event (wrk, e, events, num_ev);
2697 else
2698 vec_add1 (wrk->unhandled_evts_vector, *e);
Florin Coras99368312018-08-02 10:45:44 -07002699 svm_msg_q_free_msg (mq, msg);
Florin Coras54693d22018-07-17 10:46:29 -07002700 }
Florin Corasaa27eb92018-10-13 12:20:01 -07002701 vec_reset_length (wrk->mq_msg_vector);
Florin Coras86f04502018-09-12 16:08:01 -07002702
Florin Coras54693d22018-07-17 10:46:29 -07002703 return *num_ev;
2704}
2705
Florin Coras99368312018-08-02 10:45:44 -07002706static int
Florin Coras134a9962018-08-28 11:32:04 -07002707vppcom_epoll_wait_condvar (vcl_worker_t * wrk, struct epoll_event *events,
Florin Coras86f04502018-09-12 16:08:01 -07002708 int maxevents, u32 n_evts, double wait_for_time)
Florin Coras99368312018-08-02 10:45:44 -07002709{
2710 vcl_cut_through_registration_t *cr;
2711 double total_wait = 0, wait_slice;
Florin Coras99368312018-08-02 10:45:44 -07002712 int rv;
2713
2714 wait_for_time = (wait_for_time == -1) ? (double) 10e9 : wait_for_time;
Florin Coras134a9962018-08-28 11:32:04 -07002715 wait_slice = wrk->cut_through_registrations ? 10e-6 : wait_for_time;
Florin Coras99368312018-08-02 10:45:44 -07002716
2717 do
2718 {
Florin Coras134a9962018-08-28 11:32:04 -07002719 vcl_ct_registration_lock (wrk);
Florin Coras99368312018-08-02 10:45:44 -07002720 /* *INDENT-OFF* */
Florin Coras134a9962018-08-28 11:32:04 -07002721 pool_foreach (cr, wrk->cut_through_registrations, ({
Florin Coras86f04502018-09-12 16:08:01 -07002722 vcl_epoll_wait_handle_mq (wrk, cr->mq, events, maxevents, 0, &n_evts);
Florin Coras99368312018-08-02 10:45:44 -07002723 }));
2724 /* *INDENT-ON* */
Florin Coras134a9962018-08-28 11:32:04 -07002725 vcl_ct_registration_unlock (wrk);
Florin Coras99368312018-08-02 10:45:44 -07002726
Florin Coras134a9962018-08-28 11:32:04 -07002727 rv = vcl_epoll_wait_handle_mq (wrk, wrk->app_event_queue, events,
Florin Coras86f04502018-09-12 16:08:01 -07002728 maxevents, n_evts ? 0 : wait_slice,
2729 &n_evts);
Florin Coras99368312018-08-02 10:45:44 -07002730 if (rv)
2731 total_wait += wait_slice;
Florin Coras86f04502018-09-12 16:08:01 -07002732 if (n_evts)
2733 return n_evts;
Florin Coras99368312018-08-02 10:45:44 -07002734 }
2735 while (total_wait < wait_for_time);
Florin Coras86f04502018-09-12 16:08:01 -07002736 return n_evts;
Florin Coras99368312018-08-02 10:45:44 -07002737}
2738
2739static int
Florin Coras134a9962018-08-28 11:32:04 -07002740vppcom_epoll_wait_eventfd (vcl_worker_t * wrk, struct epoll_event *events,
Florin Coras86f04502018-09-12 16:08:01 -07002741 int maxevents, u32 n_evts, double wait_for_time)
Florin Coras99368312018-08-02 10:45:44 -07002742{
2743 vcl_mq_evt_conn_t *mqc;
2744 int __clib_unused n_read;
2745 int n_mq_evts, i;
Florin Coras99368312018-08-02 10:45:44 -07002746 u64 buf;
2747
Florin Coras134a9962018-08-28 11:32:04 -07002748 vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
Florin Corasa4878ed2018-10-12 13:09:36 -07002749again:
Florin Coras134a9962018-08-28 11:32:04 -07002750 n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
2751 vec_len (wrk->mq_events), wait_for_time);
Florin Coras99368312018-08-02 10:45:44 -07002752 for (i = 0; i < n_mq_evts; i++)
2753 {
Florin Coras134a9962018-08-28 11:32:04 -07002754 mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
Florin Coras99368312018-08-02 10:45:44 -07002755 n_read = read (mqc->mq_fd, &buf, sizeof (buf));
Florin Coras134a9962018-08-28 11:32:04 -07002756 vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0, &n_evts);
Florin Coras99368312018-08-02 10:45:44 -07002757 }
Florin Corasa4878ed2018-10-12 13:09:36 -07002758 if (!n_evts && n_mq_evts > 0)
2759 goto again;
Florin Coras99368312018-08-02 10:45:44 -07002760
2761 return (int) n_evts;
2762}
2763
Dave Wallacef7f809c2017-10-03 01:48:42 -04002764int
Florin Coras134a9962018-08-28 11:32:04 -07002765vppcom_epoll_wait (uint32_t vep_handle, struct epoll_event *events,
Dave Wallacef7f809c2017-10-03 01:48:42 -04002766 int maxevents, double wait_for_time)
2767{
Florin Coras134a9962018-08-28 11:32:04 -07002768 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07002769 vcl_session_t *vep_session;
Florin Coras86f04502018-09-12 16:08:01 -07002770 u32 n_evts = 0;
2771 int i;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002772
2773 if (PREDICT_FALSE (maxevents <= 0))
2774 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002775 clib_warning ("VCL<%d>: ERROR: Invalid maxevents (%d)!",
Dave Wallace4878cbe2017-11-21 03:45:09 -05002776 getpid (), maxevents);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002777 return VPPCOM_EINVAL;
2778 }
Dave Wallacef7f809c2017-10-03 01:48:42 -04002779
Florin Coras134a9962018-08-28 11:32:04 -07002780 vep_session = vcl_session_get_w_handle (wrk, vep_handle);
Florin Coras14598772018-09-04 19:47:52 -07002781 if (!vep_session)
2782 return VPPCOM_EBADFD;
2783
Florin Coras54693d22018-07-17 10:46:29 -07002784 if (PREDICT_FALSE (!vep_session->is_vep))
Dave Wallacef7f809c2017-10-03 01:48:42 -04002785 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002786 clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
Florin Coras134a9962018-08-28 11:32:04 -07002787 getpid (), vep_handle);
Florin Coras54693d22018-07-17 10:46:29 -07002788 return VPPCOM_EINVAL;
Dave Wallacef7f809c2017-10-03 01:48:42 -04002789 }
Florin Coras54693d22018-07-17 10:46:29 -07002790
2791 memset (events, 0, sizeof (*events) * maxevents);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002792
Florin Coras86f04502018-09-12 16:08:01 -07002793 if (vec_len (wrk->unhandled_evts_vector))
2794 {
2795 for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
2796 {
2797 vcl_epoll_wait_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i],
2798 events, &n_evts);
2799 if (n_evts == maxevents)
2800 {
2801 i += 1;
2802 break;
2803 }
2804 }
Dave Wallacef7f809c2017-10-03 01:48:42 -04002805
Florin Coras86f04502018-09-12 16:08:01 -07002806 vec_delete (wrk->unhandled_evts_vector, i, 0);
2807 }
2808
2809 if (vcm->cfg.use_mq_eventfd)
2810 return vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
2811 wait_for_time);
2812
2813 return vppcom_epoll_wait_condvar (wrk, events, maxevents, n_evts,
2814 wait_for_time);
Dave Wallacef7f809c2017-10-03 01:48:42 -04002815}
2816
Dave Wallace35830af2017-10-09 01:43:42 -04002817int
Florin Coras134a9962018-08-28 11:32:04 -07002818vppcom_session_attr (uint32_t session_handle, uint32_t op,
Dave Wallace35830af2017-10-09 01:43:42 -04002819 void *buffer, uint32_t * buflen)
2820{
Florin Coras134a9962018-08-28 11:32:04 -07002821 vcl_worker_t *wrk = vcl_worker_get_current ();
Florin Coras7e12d942018-06-27 14:32:43 -07002822 vcl_session_t *session;
Dave Wallace35830af2017-10-09 01:43:42 -04002823 int rv = VPPCOM_OK;
2824 u32 *flags = buffer;
Steven2199aab2017-10-15 20:18:47 -07002825 vppcom_endpt_t *ep = buffer;
Dave Wallace35830af2017-10-09 01:43:42 -04002826
Florin Coras134a9962018-08-28 11:32:04 -07002827 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07002828 if (!session)
2829 return VPPCOM_EBADFD;
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08002830
Dave Wallace35830af2017-10-09 01:43:42 -04002831 switch (op)
2832 {
2833 case VPPCOM_ATTR_GET_NREAD:
Florin Coras54693d22018-07-17 10:46:29 -07002834 rv = vppcom_session_read_ready (session);
Florin Coras0d427d82018-06-27 03:24:07 -07002835 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
2836 getpid (), rv);
Dave Wallace35830af2017-10-09 01:43:42 -04002837 break;
2838
Dave Wallace227867f2017-11-13 21:21:53 -05002839 case VPPCOM_ATTR_GET_NWRITE:
Florin Coras134a9962018-08-28 11:32:04 -07002840 rv = vppcom_session_write_ready (session);
Florin Coras0d427d82018-06-27 03:24:07 -07002841 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
Florin Coras134a9962018-08-28 11:32:04 -07002842 getpid (), session_handle, rv);
Dave Wallace35830af2017-10-09 01:43:42 -04002843 break;
2844
2845 case VPPCOM_ATTR_GET_FLAGS:
Dave Wallace048b1d62018-01-03 22:24:41 -05002846 if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
Dave Wallace35830af2017-10-09 01:43:42 -04002847 {
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08002848 *flags = O_RDWR | (VCL_SESS_ATTR_TEST (session->attr,
2849 VCL_SESS_ATTR_NONBLOCK));
Dave Wallace35830af2017-10-09 01:43:42 -04002850 *buflen = sizeof (*flags);
Florin Coras0d427d82018-06-27 03:24:07 -07002851 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, flags = 0x%08x, "
2852 "is_nonblocking = %u", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07002853 session_handle, *flags,
Florin Coras0d427d82018-06-27 03:24:07 -07002854 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
Dave Wallace35830af2017-10-09 01:43:42 -04002855 }
2856 else
2857 rv = VPPCOM_EINVAL;
2858 break;
2859
2860 case VPPCOM_ATTR_SET_FLAGS:
Dave Wallace048b1d62018-01-03 22:24:41 -05002861 if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
Dave Wallace35830af2017-10-09 01:43:42 -04002862 {
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08002863 if (*flags & O_NONBLOCK)
2864 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
2865 else
2866 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
2867
Florin Coras0d427d82018-06-27 03:24:07 -07002868 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, flags = 0x%08x,"
2869 " is_nonblocking = %u",
Florin Coras134a9962018-08-28 11:32:04 -07002870 getpid (), session_handle, *flags,
Florin Coras0d427d82018-06-27 03:24:07 -07002871 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
Dave Wallace35830af2017-10-09 01:43:42 -04002872 }
2873 else
2874 rv = VPPCOM_EINVAL;
2875 break;
2876
2877 case VPPCOM_ATTR_GET_PEER_ADDR:
Dave Wallace048b1d62018-01-03 22:24:41 -05002878 if (PREDICT_TRUE (buffer && buflen &&
2879 (*buflen >= sizeof (*ep)) && ep->ip))
Dave Wallace35830af2017-10-09 01:43:42 -04002880 {
Florin Coras7e12d942018-06-27 14:32:43 -07002881 ep->is_ip4 = session->transport.is_ip4;
2882 ep->port = session->transport.rmt_port;
2883 if (session->transport.is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05002884 clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
2885 sizeof (ip4_address_t));
Steven2199aab2017-10-15 20:18:47 -07002886 else
Dave Barach178cf492018-11-13 16:34:13 -05002887 clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
2888 sizeof (ip6_address_t));
Steven2199aab2017-10-15 20:18:47 -07002889 *buflen = sizeof (*ep);
Florin Coras0d427d82018-06-27 03:24:07 -07002890 VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, is_ip4 = %u, "
2891 "addr = %U, port %u", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07002892 session_handle, ep->is_ip4, format_ip46_address,
Florin Coras7e12d942018-06-27 14:32:43 -07002893 &session->transport.rmt_ip,
Florin Coras0d427d82018-06-27 03:24:07 -07002894 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2895 clib_net_to_host_u16 (ep->port));
Dave Wallace35830af2017-10-09 01:43:42 -04002896 }
2897 else
2898 rv = VPPCOM_EINVAL;
2899 break;
2900
2901 case VPPCOM_ATTR_GET_LCL_ADDR:
Dave Wallace048b1d62018-01-03 22:24:41 -05002902 if (PREDICT_TRUE (buffer && buflen &&
2903 (*buflen >= sizeof (*ep)) && ep->ip))
Dave Wallace35830af2017-10-09 01:43:42 -04002904 {
Florin Coras7e12d942018-06-27 14:32:43 -07002905 ep->is_ip4 = session->transport.is_ip4;
2906 ep->port = session->transport.lcl_port;
2907 if (session->transport.is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05002908 clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip4,
2909 sizeof (ip4_address_t));
Steven2199aab2017-10-15 20:18:47 -07002910 else
Dave Barach178cf492018-11-13 16:34:13 -05002911 clib_memcpy_fast (ep->ip, &session->transport.lcl_ip.ip6,
2912 sizeof (ip6_address_t));
Steven2199aab2017-10-15 20:18:47 -07002913 *buflen = sizeof (*ep);
Florin Coras0d427d82018-06-27 03:24:07 -07002914 VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, is_ip4 = %u,"
2915 " addr = %U port %d", getpid (),
Florin Coras134a9962018-08-28 11:32:04 -07002916 session_handle, ep->is_ip4, format_ip46_address,
Florin Coras7e12d942018-06-27 14:32:43 -07002917 &session->transport.lcl_ip,
Florin Coras0d427d82018-06-27 03:24:07 -07002918 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2919 clib_net_to_host_u16 (ep->port));
Dave Wallace35830af2017-10-09 01:43:42 -04002920 }
2921 else
2922 rv = VPPCOM_EINVAL;
2923 break;
Stevenb5a11602017-10-11 09:59:30 -07002924
Dave Wallace048b1d62018-01-03 22:24:41 -05002925 case VPPCOM_ATTR_GET_LIBC_EPFD:
2926 rv = session->libc_epfd;
Florin Coras0d427d82018-06-27 03:24:07 -07002927 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
2928 getpid (), rv);
Dave Wallace048b1d62018-01-03 22:24:41 -05002929 break;
2930
2931 case VPPCOM_ATTR_SET_LIBC_EPFD:
2932 if (PREDICT_TRUE (buffer && buflen &&
2933 (*buflen == sizeof (session->libc_epfd))))
2934 {
2935 session->libc_epfd = *(int *) buffer;
2936 *buflen = sizeof (session->libc_epfd);
2937
Florin Coras0d427d82018-06-27 03:24:07 -07002938 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
2939 "buflen %d", getpid (), session->libc_epfd, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05002940 }
2941 else
2942 rv = VPPCOM_EINVAL;
2943 break;
2944
2945 case VPPCOM_ATTR_GET_PROTOCOL:
2946 if (buffer && buflen && (*buflen >= sizeof (int)))
2947 {
Florin Coras7e12d942018-06-27 14:32:43 -07002948 *(int *) buffer = session->session_type;
Dave Wallace048b1d62018-01-03 22:24:41 -05002949 *buflen = sizeof (int);
2950
Florin Coras0d427d82018-06-27 03:24:07 -07002951 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
2952 getpid (), *(int *) buffer, *(int *) buffer ? "UDP" : "TCP",
2953 *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05002954 }
2955 else
2956 rv = VPPCOM_EINVAL;
2957 break;
2958
2959 case VPPCOM_ATTR_GET_LISTEN:
2960 if (buffer && buflen && (*buflen >= sizeof (int)))
2961 {
2962 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2963 VCL_SESS_ATTR_LISTEN);
2964 *buflen = sizeof (int);
2965
Florin Coras0d427d82018-06-27 03:24:07 -07002966 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, buflen %d",
2967 getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05002968 }
2969 else
2970 rv = VPPCOM_EINVAL;
2971 break;
2972
2973 case VPPCOM_ATTR_GET_ERROR:
2974 if (buffer && buflen && (*buflen >= sizeof (int)))
2975 {
2976 *(int *) buffer = 0;
2977 *buflen = sizeof (int);
2978
Florin Coras0d427d82018-06-27 03:24:07 -07002979 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
2980 getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05002981 }
2982 else
2983 rv = VPPCOM_EINVAL;
2984 break;
2985
2986 case VPPCOM_ATTR_GET_TX_FIFO_LEN:
2987 if (buffer && buflen && (*buflen >= sizeof (u32)))
2988 {
Dave Wallace048b1d62018-01-03 22:24:41 -05002989
2990 /* VPP-TBD */
2991 *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08002992 session->tx_fifo ? session->tx_fifo->nitems :
Dave Wallace048b1d62018-01-03 22:24:41 -05002993 vcm->cfg.tx_fifo_size);
2994 *buflen = sizeof (u32);
2995
Florin Coras0d427d82018-06-27 03:24:07 -07002996 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
2997 "buflen %d, #VPP-TBD#", getpid (),
2998 *(size_t *) buffer, *(size_t *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05002999 }
3000 else
3001 rv = VPPCOM_EINVAL;
3002 break;
3003
3004 case VPPCOM_ATTR_SET_TX_FIFO_LEN:
3005 if (buffer && buflen && (*buflen == sizeof (u32)))
3006 {
3007 /* VPP-TBD */
3008 session->sndbuf_size = *(u32 *) buffer;
Florin Coras0d427d82018-06-27 03:24:07 -07003009 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
3010 "buflen %d, #VPP-TBD#", getpid (),
3011 session->sndbuf_size, session->sndbuf_size, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003012 }
3013 else
3014 rv = VPPCOM_EINVAL;
3015 break;
3016
3017 case VPPCOM_ATTR_GET_RX_FIFO_LEN:
3018 if (buffer && buflen && (*buflen >= sizeof (u32)))
3019 {
Dave Wallace048b1d62018-01-03 22:24:41 -05003020
3021 /* VPP-TBD */
3022 *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
Keith Burns (alagalah)9b793772018-02-16 08:20:56 -08003023 session->rx_fifo ? session->rx_fifo->nitems :
Dave Wallace048b1d62018-01-03 22:24:41 -05003024 vcm->cfg.rx_fifo_size);
3025 *buflen = sizeof (u32);
3026
Florin Coras0d427d82018-06-27 03:24:07 -07003027 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
3028 "buflen %d, #VPP-TBD#", getpid (),
3029 *(size_t *) buffer, *(size_t *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003030 }
3031 else
3032 rv = VPPCOM_EINVAL;
3033 break;
3034
3035 case VPPCOM_ATTR_SET_RX_FIFO_LEN:
3036 if (buffer && buflen && (*buflen == sizeof (u32)))
3037 {
3038 /* VPP-TBD */
3039 session->rcvbuf_size = *(u32 *) buffer;
Florin Coras0d427d82018-06-27 03:24:07 -07003040 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
3041 "buflen %d, #VPP-TBD#", getpid (),
3042 session->sndbuf_size, session->sndbuf_size, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003043 }
3044 else
3045 rv = VPPCOM_EINVAL;
3046 break;
3047
3048 case VPPCOM_ATTR_GET_REUSEADDR:
3049 if (buffer && buflen && (*buflen >= sizeof (int)))
3050 {
3051 /* VPP-TBD */
3052 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3053 VCL_SESS_ATTR_REUSEADDR);
3054 *buflen = sizeof (int);
3055
Florin Coras0d427d82018-06-27 03:24:07 -07003056 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
3057 "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003058 }
3059 else
3060 rv = VPPCOM_EINVAL;
3061 break;
3062
Stevenb5a11602017-10-11 09:59:30 -07003063 case VPPCOM_ATTR_SET_REUSEADDR:
Dave Wallace048b1d62018-01-03 22:24:41 -05003064 if (buffer && buflen && (*buflen == sizeof (int)) &&
3065 !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
3066 {
3067 /* VPP-TBD */
3068 if (*(int *) buffer)
3069 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEADDR);
3070 else
3071 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
3072
Florin Coras0d427d82018-06-27 03:24:07 -07003073 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d,"
3074 " #VPP-TBD#", getpid (),
3075 VCL_SESS_ATTR_TEST (session->attr,
3076 VCL_SESS_ATTR_REUSEADDR), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003077 }
3078 else
3079 rv = VPPCOM_EINVAL;
3080 break;
3081
3082 case VPPCOM_ATTR_GET_REUSEPORT:
3083 if (buffer && buflen && (*buflen >= sizeof (int)))
3084 {
3085 /* VPP-TBD */
3086 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3087 VCL_SESS_ATTR_REUSEPORT);
3088 *buflen = sizeof (int);
3089
Florin Coras0d427d82018-06-27 03:24:07 -07003090 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d,"
3091 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003092 }
3093 else
3094 rv = VPPCOM_EINVAL;
3095 break;
3096
3097 case VPPCOM_ATTR_SET_REUSEPORT:
3098 if (buffer && buflen && (*buflen == sizeof (int)) &&
3099 !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
3100 {
3101 /* VPP-TBD */
3102 if (*(int *) buffer)
3103 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEPORT);
3104 else
3105 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
3106
Florin Coras0d427d82018-06-27 03:24:07 -07003107 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d,"
3108 " #VPP-TBD#", getpid (),
3109 VCL_SESS_ATTR_TEST (session->attr,
3110 VCL_SESS_ATTR_REUSEPORT), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003111 }
3112 else
3113 rv = VPPCOM_EINVAL;
3114 break;
3115
3116 case VPPCOM_ATTR_GET_BROADCAST:
3117 if (buffer && buflen && (*buflen >= sizeof (int)))
3118 {
3119 /* VPP-TBD */
3120 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3121 VCL_SESS_ATTR_BROADCAST);
3122 *buflen = sizeof (int);
3123
Florin Coras0d427d82018-06-27 03:24:07 -07003124 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d,"
3125 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003126 }
3127 else
3128 rv = VPPCOM_EINVAL;
Stevenb5a11602017-10-11 09:59:30 -07003129 break;
3130
3131 case VPPCOM_ATTR_SET_BROADCAST:
Dave Wallace048b1d62018-01-03 22:24:41 -05003132 if (buffer && buflen && (*buflen == sizeof (int)))
3133 {
3134 /* VPP-TBD */
3135 if (*(int *) buffer)
3136 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_BROADCAST);
3137 else
3138 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
3139
Florin Coras0d427d82018-06-27 03:24:07 -07003140 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, "
3141 "#VPP-TBD#", getpid (),
3142 VCL_SESS_ATTR_TEST (session->attr,
3143 VCL_SESS_ATTR_BROADCAST), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003144 }
3145 else
3146 rv = VPPCOM_EINVAL;
3147 break;
3148
3149 case VPPCOM_ATTR_GET_V6ONLY:
3150 if (buffer && buflen && (*buflen >= sizeof (int)))
3151 {
3152 /* VPP-TBD */
3153 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3154 VCL_SESS_ATTR_V6ONLY);
3155 *buflen = sizeof (int);
3156
Florin Coras0d427d82018-06-27 03:24:07 -07003157 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, "
3158 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003159 }
3160 else
3161 rv = VPPCOM_EINVAL;
Stevenb5a11602017-10-11 09:59:30 -07003162 break;
3163
3164 case VPPCOM_ATTR_SET_V6ONLY:
Dave Wallace048b1d62018-01-03 22:24:41 -05003165 if (buffer && buflen && (*buflen == sizeof (int)))
3166 {
3167 /* VPP-TBD */
3168 if (*(int *) buffer)
3169 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_V6ONLY);
3170 else
3171 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
3172
Florin Coras0d427d82018-06-27 03:24:07 -07003173 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, "
3174 "#VPP-TBD#", getpid (),
3175 VCL_SESS_ATTR_TEST (session->attr,
3176 VCL_SESS_ATTR_V6ONLY), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003177 }
3178 else
3179 rv = VPPCOM_EINVAL;
3180 break;
3181
3182 case VPPCOM_ATTR_GET_KEEPALIVE:
3183 if (buffer && buflen && (*buflen >= sizeof (int)))
3184 {
3185 /* VPP-TBD */
3186 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3187 VCL_SESS_ATTR_KEEPALIVE);
3188 *buflen = sizeof (int);
3189
Florin Coras0d427d82018-06-27 03:24:07 -07003190 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, "
3191 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003192 }
3193 else
3194 rv = VPPCOM_EINVAL;
Stevenb5a11602017-10-11 09:59:30 -07003195 break;
Stevenbccd3392017-10-12 20:42:21 -07003196
3197 case VPPCOM_ATTR_SET_KEEPALIVE:
Dave Wallace048b1d62018-01-03 22:24:41 -05003198 if (buffer && buflen && (*buflen == sizeof (int)))
3199 {
3200 /* VPP-TBD */
3201 if (*(int *) buffer)
3202 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_KEEPALIVE);
3203 else
3204 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
3205
Florin Coras0d427d82018-06-27 03:24:07 -07003206 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, "
3207 "#VPP-TBD#", getpid (),
3208 VCL_SESS_ATTR_TEST (session->attr,
3209 VCL_SESS_ATTR_KEEPALIVE), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003210 }
3211 else
3212 rv = VPPCOM_EINVAL;
3213 break;
3214
3215 case VPPCOM_ATTR_GET_TCP_NODELAY:
3216 if (buffer && buflen && (*buflen >= sizeof (int)))
3217 {
3218 /* VPP-TBD */
3219 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3220 VCL_SESS_ATTR_TCP_NODELAY);
3221 *buflen = sizeof (int);
3222
Florin Coras0d427d82018-06-27 03:24:07 -07003223 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, "
3224 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003225 }
3226 else
3227 rv = VPPCOM_EINVAL;
3228 break;
3229
3230 case VPPCOM_ATTR_SET_TCP_NODELAY:
3231 if (buffer && buflen && (*buflen == sizeof (int)))
3232 {
3233 /* VPP-TBD */
3234 if (*(int *) buffer)
3235 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
3236 else
3237 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
3238
Florin Coras0d427d82018-06-27 03:24:07 -07003239 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, "
3240 "#VPP-TBD#", getpid (),
3241 VCL_SESS_ATTR_TEST (session->attr,
3242 VCL_SESS_ATTR_TCP_NODELAY), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003243 }
3244 else
3245 rv = VPPCOM_EINVAL;
3246 break;
3247
3248 case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
3249 if (buffer && buflen && (*buflen >= sizeof (int)))
3250 {
3251 /* VPP-TBD */
3252 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3253 VCL_SESS_ATTR_TCP_KEEPIDLE);
3254 *buflen = sizeof (int);
3255
Florin Coras0d427d82018-06-27 03:24:07 -07003256 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, "
3257 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003258 }
3259 else
3260 rv = VPPCOM_EINVAL;
Stevenbccd3392017-10-12 20:42:21 -07003261 break;
3262
3263 case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
Dave Wallace048b1d62018-01-03 22:24:41 -05003264 if (buffer && buflen && (*buflen == sizeof (int)))
3265 {
3266 /* VPP-TBD */
3267 if (*(int *) buffer)
3268 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
3269 else
3270 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
3271
Florin Coras0d427d82018-06-27 03:24:07 -07003272 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, "
3273 "#VPP-TBD#", getpid (),
3274 VCL_SESS_ATTR_TEST (session->attr,
3275 VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003276 }
3277 else
3278 rv = VPPCOM_EINVAL;
3279 break;
3280
3281 case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
3282 if (buffer && buflen && (*buflen >= sizeof (int)))
3283 {
3284 /* VPP-TBD */
3285 *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3286 VCL_SESS_ATTR_TCP_KEEPINTVL);
3287 *buflen = sizeof (int);
3288
Florin Coras0d427d82018-06-27 03:24:07 -07003289 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, "
3290 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003291 }
3292 else
3293 rv = VPPCOM_EINVAL;
Stevenbccd3392017-10-12 20:42:21 -07003294 break;
3295
3296 case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
Dave Wallace048b1d62018-01-03 22:24:41 -05003297 if (buffer && buflen && (*buflen == sizeof (int)))
3298 {
3299 /* VPP-TBD */
3300 if (*(int *) buffer)
3301 VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
3302 else
3303 VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
3304
Florin Coras0d427d82018-06-27 03:24:07 -07003305 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, "
3306 "#VPP-TBD#", getpid (),
3307 VCL_SESS_ATTR_TEST (session->attr,
3308 VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003309 }
3310 else
3311 rv = VPPCOM_EINVAL;
3312 break;
3313
3314 case VPPCOM_ATTR_GET_TCP_USER_MSS:
3315 if (buffer && buflen && (*buflen >= sizeof (u32)))
3316 {
3317 /* VPP-TBD */
3318 *(u32 *) buffer = session->user_mss;
3319 *buflen = sizeof (int);
3320
Florin Coras0d427d82018-06-27 03:24:07 -07003321 VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d,"
3322 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003323 }
3324 else
3325 rv = VPPCOM_EINVAL;
3326 break;
3327
3328 case VPPCOM_ATTR_SET_TCP_USER_MSS:
3329 if (buffer && buflen && (*buflen == sizeof (u32)))
3330 {
3331 /* VPP-TBD */
3332 session->user_mss = *(u32 *) buffer;
3333
Florin Coras0d427d82018-06-27 03:24:07 -07003334 VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d, "
3335 "#VPP-TBD#", getpid (), session->user_mss, *buflen);
Dave Wallace048b1d62018-01-03 22:24:41 -05003336 }
3337 else
3338 rv = VPPCOM_EINVAL;
Stevenbccd3392017-10-12 20:42:21 -07003339 break;
Dave Wallacee22aa742017-10-20 12:30:38 -04003340
Florin Coras47c40e22018-11-26 17:01:36 -08003341 case VPPCOM_ATTR_GET_REFCNT:
3342 rv = vcl_session_get_refcnt (session);
3343 break;
3344
Dave Wallacee22aa742017-10-20 12:30:38 -04003345 default:
3346 rv = VPPCOM_EINVAL;
3347 break;
Dave Wallace35830af2017-10-09 01:43:42 -04003348 }
3349
Dave Wallace35830af2017-10-09 01:43:42 -04003350 return rv;
3351}
3352
Stevenac1f96d2017-10-24 16:03:58 -07003353int
Florin Coras134a9962018-08-28 11:32:04 -07003354vppcom_session_recvfrom (uint32_t session_handle, void *buffer,
Stevenac1f96d2017-10-24 16:03:58 -07003355 uint32_t buflen, int flags, vppcom_endpt_t * ep)
3356{
Florin Coras134a9962018-08-28 11:32:04 -07003357 vcl_worker_t *wrk = vcl_worker_get_current ();
Stevenac1f96d2017-10-24 16:03:58 -07003358 int rv = VPPCOM_OK;
Florin Coras7e12d942018-06-27 14:32:43 -07003359 vcl_session_t *session = 0;
Stevenac1f96d2017-10-24 16:03:58 -07003360
3361 if (ep)
3362 {
Florin Coras134a9962018-08-28 11:32:04 -07003363 session = vcl_session_get_w_handle (wrk, session_handle);
Florin Coras070453d2018-08-24 17:04:27 -07003364 if (PREDICT_FALSE (!session))
Stevenac1f96d2017-10-24 16:03:58 -07003365 {
Florin Coras0d427d82018-06-27 03:24:07 -07003366 VDBG (0, "VCL<%d>: invalid session, sid (%u) has been closed!",
Florin Coras134a9962018-08-28 11:32:04 -07003367 getpid (), session_handle);
Florin Coras460dce62018-07-27 05:45:06 -07003368 return VPPCOM_EBADFD;
Stevenac1f96d2017-10-24 16:03:58 -07003369 }
Florin Coras7e12d942018-06-27 14:32:43 -07003370 ep->is_ip4 = session->transport.is_ip4;
3371 ep->port = session->transport.rmt_port;
Stevenac1f96d2017-10-24 16:03:58 -07003372 }
Steven58f464e2017-10-25 12:33:12 -07003373
3374 if (flags == 0)
Florin Coras134a9962018-08-28 11:32:04 -07003375 rv = vppcom_session_read (session_handle, buffer, buflen);
Stevenac1f96d2017-10-24 16:03:58 -07003376 else if (flags & MSG_PEEK)
Florin Coras134a9962018-08-28 11:32:04 -07003377 rv = vppcom_session_peek (session_handle, buffer, buflen);
Stevenac1f96d2017-10-24 16:03:58 -07003378 else
3379 {
Dave Wallace048b1d62018-01-03 22:24:41 -05003380 clib_warning ("VCL<%d>: Unsupport flags for recvfrom %d",
3381 getpid (), flags);
Florin Coras460dce62018-07-27 05:45:06 -07003382 return VPPCOM_EAFNOSUPPORT;
Stevenac1f96d2017-10-24 16:03:58 -07003383 }
3384
Florin Coras99368312018-08-02 10:45:44 -07003385 if (ep)
3386 {
3387 if (session->transport.is_ip4)
Dave Barach178cf492018-11-13 16:34:13 -05003388 clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip4,
3389 sizeof (ip4_address_t));
Florin Coras99368312018-08-02 10:45:44 -07003390 else
Dave Barach178cf492018-11-13 16:34:13 -05003391 clib_memcpy_fast (ep->ip, &session->transport.rmt_ip.ip6,
3392 sizeof (ip6_address_t));
Florin Coras99368312018-08-02 10:45:44 -07003393 }
Florin Coras460dce62018-07-27 05:45:06 -07003394
Stevenac1f96d2017-10-24 16:03:58 -07003395 return rv;
3396}
3397
3398int
Florin Coras134a9962018-08-28 11:32:04 -07003399vppcom_session_sendto (uint32_t session_handle, void *buffer,
Stevenac1f96d2017-10-24 16:03:58 -07003400 uint32_t buflen, int flags, vppcom_endpt_t * ep)
3401{
Dave Wallace617dffa2017-10-26 14:47:06 -04003402 if (!buffer)
3403 return VPPCOM_EINVAL;
3404
3405 if (ep)
3406 {
3407 // TBD
3408 return VPPCOM_EINVAL;
3409 }
3410
3411 if (flags)
3412 {
3413 // TBD check the flags and do the right thing
Florin Coras0d427d82018-06-27 03:24:07 -07003414 VDBG (2, "VCL<%d>: handling flags 0x%u (%d) not implemented yet.",
3415 getpid (), flags, flags);
Dave Wallace617dffa2017-10-26 14:47:06 -04003416 }
3417
Florin Coras42ceddb2018-12-12 10:56:01 -08003418 return (vppcom_session_write_inline (session_handle, buffer, buflen, 1));
Stevenac1f96d2017-10-24 16:03:58 -07003419}
3420
Dave Wallace048b1d62018-01-03 22:24:41 -05003421int
3422vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
3423{
Florin Coras134a9962018-08-28 11:32:04 -07003424 vcl_worker_t *wrk = vcl_worker_get_current ();
3425 f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
Dave Wallace048b1d62018-01-03 22:24:41 -05003426 u32 i, keep_trying = 1;
Florin Coras6917b942018-11-13 22:44:54 -08003427 svm_msg_q_msg_t msg;
3428 session_event_t *e;
Dave Wallace048b1d62018-01-03 22:24:41 -05003429 int rv, num_ev = 0;
3430
Florin Coras0d427d82018-06-27 03:24:07 -07003431 VDBG (3, "VCL<%d>: vp %p, nsids %u, wait_for_time %f",
3432 getpid (), vp, n_sids, wait_for_time);
Dave Wallace048b1d62018-01-03 22:24:41 -05003433
3434 if (!vp)
3435 return VPPCOM_EFAULT;
3436
3437 do
3438 {
Florin Coras7e12d942018-06-27 14:32:43 -07003439 vcl_session_t *session;
Dave Wallace048b1d62018-01-03 22:24:41 -05003440
Florin Coras6917b942018-11-13 22:44:54 -08003441 /* Dequeue all events and drop all unhandled io events */
3442 while (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0) == 0)
3443 {
3444 e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
3445 vcl_handle_mq_event (wrk, e);
3446 svm_msg_q_free_msg (wrk->app_event_queue, &msg);
3447 }
3448 vec_reset_length (wrk->unhandled_evts_vector);
3449
Dave Wallace048b1d62018-01-03 22:24:41 -05003450 for (i = 0; i < n_sids; i++)
3451 {
Florin Coras134a9962018-08-28 11:32:04 -07003452 session = vcl_session_get (wrk, vp[i].sid);
Florin Coras070453d2018-08-24 17:04:27 -07003453 if (!session)
Florin Coras6917b942018-11-13 22:44:54 -08003454 {
3455 vp[i].revents = POLLHUP;
3456 num_ev++;
3457 continue;
3458 }
Dave Wallace048b1d62018-01-03 22:24:41 -05003459
Florin Coras6917b942018-11-13 22:44:54 -08003460 vp[i].revents = 0;
Dave Wallace048b1d62018-01-03 22:24:41 -05003461
3462 if (POLLIN & vp[i].events)
3463 {
Florin Coras54693d22018-07-17 10:46:29 -07003464 rv = vppcom_session_read_ready (session);
Dave Wallace048b1d62018-01-03 22:24:41 -05003465 if (rv > 0)
3466 {
Florin Coras6917b942018-11-13 22:44:54 -08003467 vp[i].revents |= POLLIN;
Dave Wallace048b1d62018-01-03 22:24:41 -05003468 num_ev++;
3469 }
3470 else if (rv < 0)
3471 {
3472 switch (rv)
3473 {
3474 case VPPCOM_ECONNRESET:
Florin Coras6917b942018-11-13 22:44:54 -08003475 vp[i].revents = POLLHUP;
Dave Wallace048b1d62018-01-03 22:24:41 -05003476 break;
3477
3478 default:
Florin Coras6917b942018-11-13 22:44:54 -08003479 vp[i].revents = POLLERR;
Dave Wallace048b1d62018-01-03 22:24:41 -05003480 break;
3481 }
3482 num_ev++;
3483 }
3484 }
3485
3486 if (POLLOUT & vp[i].events)
3487 {
Florin Coras134a9962018-08-28 11:32:04 -07003488 rv = vppcom_session_write_ready (session);
Dave Wallace048b1d62018-01-03 22:24:41 -05003489 if (rv > 0)
3490 {
Florin Coras6917b942018-11-13 22:44:54 -08003491 vp[i].revents |= POLLOUT;
Dave Wallace048b1d62018-01-03 22:24:41 -05003492 num_ev++;
3493 }
3494 else if (rv < 0)
3495 {
3496 switch (rv)
3497 {
3498 case VPPCOM_ECONNRESET:
Florin Coras6917b942018-11-13 22:44:54 -08003499 vp[i].revents = POLLHUP;
Dave Wallace048b1d62018-01-03 22:24:41 -05003500 break;
3501
3502 default:
Florin Coras6917b942018-11-13 22:44:54 -08003503 vp[i].revents = POLLERR;
Dave Wallace048b1d62018-01-03 22:24:41 -05003504 break;
3505 }
3506 num_ev++;
3507 }
3508 }
3509
Dave Wallace7e607a72018-06-18 18:41:32 -04003510 if (0) // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
Dave Wallace048b1d62018-01-03 22:24:41 -05003511 {
Florin Coras6917b942018-11-13 22:44:54 -08003512 vp[i].revents = POLLNVAL;
Dave Wallace048b1d62018-01-03 22:24:41 -05003513 num_ev++;
3514 }
3515 }
3516 if (wait_for_time != -1)
Florin Coras134a9962018-08-28 11:32:04 -07003517 keep_trying = (clib_time_now (&wrk->clib_time) <= timeout) ? 1 : 0;
Dave Wallace048b1d62018-01-03 22:24:41 -05003518 }
3519 while ((num_ev == 0) && keep_trying);
3520
3521 if (VPPCOM_DEBUG > 3)
3522 {
3523 clib_warning ("VCL<%d>: returning %d", getpid (), num_ev);
3524 for (i = 0; i < n_sids; i++)
3525 {
3526 clib_warning ("VCL<%d>: vp[%d].sid %d (0x%x), .events 0x%x, "
3527 ".revents 0x%x", getpid (), i, vp[i].sid, vp[i].sid,
Florin Coras6917b942018-11-13 22:44:54 -08003528 vp[i].events, vp[i].revents);
Dave Wallace048b1d62018-01-03 22:24:41 -05003529 }
3530 }
3531 return num_ev;
3532}
3533
Florin Coras99368312018-08-02 10:45:44 -07003534int
3535vppcom_mq_epoll_fd (void)
3536{
Florin Coras134a9962018-08-28 11:32:04 -07003537 vcl_worker_t *wrk = vcl_worker_get_current ();
3538 return wrk->mqs_epfd;
3539}
3540
3541int
3542vppcom_session_index (uint32_t session_handle)
3543{
3544 return session_handle & 0xFFFFFF;
3545}
3546
3547int
Florin Coras30e273b2018-11-27 00:04:59 -08003548vppcom_session_handle (uint32_t session_index)
3549{
Florin Coras47c40e22018-11-26 17:01:36 -08003550 return (vcl_get_worker_index () << 24) | session_index;
Florin Coras30e273b2018-11-27 00:04:59 -08003551}
3552
3553int
Florin Coras134a9962018-08-28 11:32:04 -07003554vppcom_worker_register (void)
3555{
Florin Coras47c40e22018-11-26 17:01:36 -08003556 if (!vcl_worker_alloc_and_init ())
3557 return VPPCOM_EEXIST;
3558
3559 if (vcl_worker_set_bapi ())
3560 return VPPCOM_EEXIST;
3561
3562 if (vcl_worker_register_with_vpp ())
3563 return VPPCOM_EEXIST;
3564
3565 return VPPCOM_OK;
Florin Coras99368312018-08-02 10:45:44 -07003566}
3567
Florin Corasdfe4cf42018-11-28 22:13:45 -08003568int
3569vppcom_worker_index (void)
3570{
3571 return vcl_get_worker_index ();
3572}
3573
Dave Wallacee22aa742017-10-20 12:30:38 -04003574/*
3575 * fd.io coding-style-patch-verification: ON
3576 *
3577 * Local Variables:
3578 * eval: (c-set-style "gnu")
3579 * End:
3580 */