__thread uword __vcl_worker_index = ~0;
-static int
-vcl_segment_is_not_mounted (vcl_worker_t * wrk, u64 segment_handle)
-{
- u32 segment_index;
-
- if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
- return 0;
-
- segment_index = vcl_segment_table_lookup (segment_handle);
- if (segment_index != VCL_INVALID_SEGMENT_INDEX)
- return 0;
-
- return 1;
-}
-
static inline int
vcl_mq_dequeue_batch (vcl_worker_t * wrk, svm_msg_q_t * mq, u32 n_max_msg)
{
- svm_msg_q_msg_t *msg;
- u32 n_msgs;
- int i;
+ u32 n_msgs = 0, sz, len;
- n_msgs = clib_min (svm_msg_q_size (mq), n_max_msg);
- for (i = 0; i < n_msgs; i++)
+ while ((sz = svm_msg_q_size (mq)))
{
- vec_add2 (wrk->mq_msg_vector, msg, 1);
- svm_msg_q_sub_w_lock (mq, msg);
+ len = vec_len (wrk->mq_msg_vector);
+ vec_validate (wrk->mq_msg_vector, len + sz - 1);
+ svm_msg_q_sub_raw_batch (mq, wrk->mq_msg_vector + len, sz);
+ n_msgs += sz;
}
return n_msgs;
}
* VPPCOM Utility Functions
*/
+static void
+vcl_msg_add_ext_config (vcl_session_t *s, uword *offset)
+{
+ svm_fifo_chunk_t *c;
+
+ c = vcl_segment_alloc_chunk (vcl_vpp_worker_segment_handle (0),
+ 0 /* one slice only */, s->ext_config->len,
+ offset);
+ if (c)
+ clib_memcpy_fast (c->data, s->ext_config, s->ext_config->len);
+}
+
static void
vcl_send_session_listen (vcl_worker_t * wrk, vcl_session_t * s)
{
clib_memcpy_fast (&mp->ip, &s->transport.lcl_ip, sizeof (mp->ip));
mp->port = s->transport.lcl_port;
mp->proto = s->session_type;
+ mp->ckpair_index = s->ckpair_index;
+ mp->vrf = s->vrf;
if (s->flags & VCL_SESSION_F_CONNECTED)
mp->flags = TRANSPORT_CFG_F_CONNECTED;
+ if (s->ext_config)
+ vcl_msg_add_ext_config (s, &mp->ext_config);
app_send_ctrl_evt_to_vpp (mq, app_evt);
+ if (s->ext_config)
+ {
+ clib_mem_free (s->ext_config);
+ s->ext_config = 0;
+ }
}
static void
mp->port = s->transport.rmt_port;
mp->lcl_port = s->transport.lcl_port;
mp->proto = s->session_type;
+ mp->ckpair_index = s->ckpair_index;
+ mp->vrf = s->vrf;
if (s->flags & VCL_SESSION_F_CONNECTED)
mp->flags |= TRANSPORT_CFG_F_CONNECTED;
+ if (s->ext_config)
+ vcl_msg_add_ext_config (s, &mp->ext_config);
app_send_ctrl_evt_to_vpp (mq, app_evt);
+
+ if (s->ext_config)
+ {
+ clib_mem_free (s->ext_config);
+ s->ext_config = 0;
+ }
}
void
}
static void
-vcl_send_session_disconnected_reply (svm_msg_q_t * mq, u32 context,
- session_handle_t handle, int retval)
+vcl_send_session_disconnected_reply (vcl_worker_t * wrk, vcl_session_t * s,
+ int retval)
{
app_session_evt_t _app_evt, *app_evt = &_app_evt;
session_disconnected_reply_msg_t *rmp;
- app_alloc_ctrl_evt_to_vpp (mq, app_evt,
+ app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
SESSION_CTRL_EVT_DISCONNECTED_REPLY);
rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
- rmp->handle = handle;
- rmp->context = context;
+ rmp->handle = s->vpp_handle;
+ rmp->context = wrk->api_client_handle;
rmp->retval = retval;
- app_send_ctrl_evt_to_vpp (mq, app_evt);
+ app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
}
static void
-vcl_send_session_reset_reply (svm_msg_q_t * mq, u32 context,
- session_handle_t handle, int retval)
+vcl_send_session_reset_reply (vcl_worker_t * wrk, vcl_session_t * s,
+ int retval)
{
app_session_evt_t _app_evt, *app_evt = &_app_evt;
session_reset_reply_msg_t *rmp;
- app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_RESET_REPLY);
+ app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
+ SESSION_CTRL_EVT_RESET_REPLY);
rmp = (session_reset_reply_msg_t *) app_evt->evt->data;
- rmp->handle = handle;
- rmp->context = context;
+ rmp->handle = s->vpp_handle;
+ rmp->context = wrk->api_client_handle;
rmp->retval = retval;
- app_send_ctrl_evt_to_vpp (mq, app_evt);
+ app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
}
void
{
app_session_evt_t _app_evt, *app_evt = &_app_evt;
session_worker_update_msg_t *mp;
- svm_msg_q_t *mq;
- mq = vcl_session_vpp_evt_q (wrk, s);
- app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_WORKER_UPDATE);
+ app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
+ SESSION_CTRL_EVT_WORKER_UPDATE);
mp = (session_worker_update_msg_t *) app_evt->evt->data;
mp->client_index = wrk->api_client_handle;
mp->handle = s->vpp_handle;
mp->req_wrk_index = wrk->vpp_wrk_index;
mp->wrk_index = wrk_index;
- app_send_ctrl_evt_to_vpp (mq, app_evt);
+ app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
}
int
return ret;
}
+int
+vcl_session_transport_attr (vcl_worker_t *wrk, vcl_session_t *s, u8 is_get,
+ transport_endpt_attr_t *attr)
+{
+ app_session_evt_t _app_evt, *app_evt = &_app_evt;
+ session_transport_attr_msg_t *mp;
+ svm_msg_q_t *mq;
+ f64 timeout;
+
+ ASSERT (!wrk->session_attr_op);
+ wrk->session_attr_op = 1;
+ wrk->session_attr_op_rv = -1;
+
+ mq = s->vpp_evt_q;
+ app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_TRANSPORT_ATTR);
+ mp = (session_transport_attr_msg_t *) app_evt->evt->data;
+ memset (mp, 0, sizeof (*mp));
+ mp->client_index = wrk->api_client_handle;
+ mp->handle = s->vpp_handle;
+ mp->is_get = is_get;
+ mp->attr = *attr;
+ app_send_ctrl_evt_to_vpp (mq, app_evt);
+
+ timeout = clib_time_now (&wrk->clib_time) + 1;
+
+ while (wrk->session_attr_op && clib_time_now (&wrk->clib_time) < timeout)
+ vcl_flush_mq_events ();
+
+ if (!wrk->session_attr_op_rv && is_get)
+ *attr = wrk->session_attr_rv;
+
+ wrk->session_attr_op = 0;
+
+ return wrk->session_attr_op_rv;
+}
+
static u32
vcl_session_accepted_handler (vcl_worker_t * wrk, session_accepted_msg_t * mp,
u32 ls_index)
{
vcl_session_t *session, *listen_session;
- svm_fifo_t *rx_fifo, *tx_fifo;
- u32 vpp_wrk_index;
svm_msg_q_t *evt_q;
session = vcl_session_alloc (wrk);
goto error;
}
- if (vcl_segment_is_not_mounted (wrk, mp->segment_handle))
+ if (vcl_segment_attach_session (mp->segment_handle, mp->server_rx_fifo,
+ mp->server_tx_fifo,
+ mp->vpp_event_queue_address, 0, session))
{
- VDBG (0, "ERROR: segment for session %u is not mounted!",
- session->session_index);
+ VDBG (0, "failed to attach fifos for %u", session->session_index);
goto error;
}
- rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
- tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
- session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
- svm_msg_q_t *);
- rx_fifo->client_session_index = session->session_index;
- tx_fifo->client_session_index = session->session_index;
- rx_fifo->client_thread_index = vcl_get_worker_index ();
- tx_fifo->client_thread_index = vcl_get_worker_index ();
- vpp_wrk_index = tx_fifo->master_thread_index;
- vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
- wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
-
session->vpp_handle = mp->handle;
- session->vpp_thread_index = rx_fifo->master_thread_index;
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
-
session->session_state = VCL_STATE_READY;
session->transport.rmt_port = mp->rmt.port;
session->transport.is_ip4 = mp->rmt.is_ip4;
return session->session_index;
error:
- evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
+ vcl_segment_attach_mq (vcl_vpp_worker_segment_handle (0),
+ mp->vpp_event_queue_address, mp->mq_index, &evt_q);
vcl_send_session_accepted_reply (evt_q, mp->context, mp->handle,
VNET_API_ERROR_INVALID_ARGUMENT);
vcl_session_free (wrk, session);
vcl_session_connected_handler (vcl_worker_t * wrk,
session_connected_msg_t * mp)
{
- u32 session_index, vpp_wrk_index;
- svm_fifo_t *rx_fifo, *tx_fifo;
vcl_session_t *session = 0;
+ u32 session_index;
session_index = mp->context;
session = vcl_session_get (wrk, session_index);
}
session->vpp_handle = mp->handle;
- session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
- svm_msg_q_t *);
- rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
- tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
- if (vcl_segment_is_not_mounted (wrk, mp->segment_handle))
+
+ if (vcl_segment_attach_session (mp->segment_handle, mp->server_rx_fifo,
+ mp->server_tx_fifo,
+ mp->vpp_event_queue_address, 0, session))
{
- VDBG (0, "segment for session %u is not mounted!",
- session->session_index);
+ VDBG (0, "failed to attach fifos for %u", session->session_index);
session->session_state = VCL_STATE_DETACHED;
vcl_send_session_disconnect (wrk, session);
return session_index;
}
- rx_fifo->client_session_index = session_index;
- tx_fifo->client_session_index = session_index;
- rx_fifo->client_thread_index = vcl_get_worker_index ();
- tx_fifo->client_thread_index = vcl_get_worker_index ();
-
- vpp_wrk_index = tx_fifo->master_thread_index;
- vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
- wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
-
if (mp->ct_rx_fifo)
{
- session->ct_rx_fifo = uword_to_pointer (mp->ct_rx_fifo, svm_fifo_t *);
- session->ct_tx_fifo = uword_to_pointer (mp->ct_tx_fifo, svm_fifo_t *);
- if (vcl_segment_is_not_mounted (wrk, mp->ct_segment_handle))
+ if (vcl_segment_attach_session (mp->ct_segment_handle, mp->ct_rx_fifo,
+ mp->ct_tx_fifo, (uword) ~0, 1, session))
{
- VDBG (0, "ct segment for session %u is not mounted!",
- session->session_index);
+ VDBG (0, "failed to attach ct fifos for %u", session->session_index);
session->session_state = VCL_STATE_DETACHED;
vcl_send_session_disconnect (wrk, session);
return session_index;
}
}
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
- session->vpp_thread_index = rx_fifo->master_thread_index;
session->transport.is_ip4 = mp->lcl.is_ip4;
clib_memcpy_fast (&session->transport.lcl_ip, &mp->lcl.ip,
sizeof (session->transport.lcl_ip));
vcl_session_table_add_listener (wrk, mp->handle, sid);
session->session_state = VCL_STATE_LISTEN;
- session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
- vec_validate (wrk->vpp_event_queues, 0);
- wrk->vpp_event_queues[0] = session->vpp_evt_q;
-
if (vcl_session_is_cl (session))
{
- svm_fifo_t *rx_fifo, *tx_fifo;
- session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
- rx_fifo = uword_to_pointer (mp->rx_fifo, svm_fifo_t *);
- rx_fifo->client_session_index = sid;
- tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
- tx_fifo->client_session_index = sid;
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
+ if (vcl_segment_attach_session (mp->segment_handle, mp->rx_fifo,
+ mp->tx_fifo, mp->vpp_evt_q, 0, session))
+ {
+ VDBG (0, "failed to attach fifos for %u", session->session_index);
+ session->session_state = VCL_STATE_DETACHED;
+ return VCL_INVALID_SESSION_INDEX;
+ }
}
VDBG (0, "session %u [0x%llx]: listen succeeded!", sid, mp->handle);
{
session_migrated_msg_t *mp = (session_migrated_msg_t *) data;
vcl_session_t *s;
+ u32 fs_index;
s = vcl_session_get_w_vpp_handle (wrk, mp->handle);
if (!s)
return;
}
- s->vpp_thread_index = mp->vpp_thread_index;
+ /* Only validate if a value is provided */
+ if (mp->segment_handle != SESSION_INVALID_HANDLE)
+ {
+ fs_index = vcl_segment_table_lookup (mp->segment_handle);
+ if (fs_index == VCL_INVALID_SEGMENT_INDEX)
+ {
+ VDBG (0, "segment %lx for session %u is not mounted!",
+ mp->segment_handle, s->session_index);
+ s->session_state = VCL_STATE_DETACHED;
+ return;
+ }
+ }
+
s->vpp_handle = mp->new_handle;
- s->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
- vec_validate (wrk->vpp_event_queues, s->vpp_thread_index);
- wrk->vpp_event_queues[s->vpp_thread_index] = s->vpp_evt_q;
+ vcl_segment_attach_mq (vcl_vpp_worker_segment_handle (0), mp->vpp_evt_q,
+ mp->vpp_thread_index, &s->vpp_evt_q);
vcl_session_table_del_vpp_handle (wrk, mp->handle);
vcl_session_table_add_vpp_handle (wrk, mp->new_handle, s->session_index);
/* Generate new tx event if we have outstanding data */
if (svm_fifo_has_event (s->tx_fifo))
- app_send_io_evt_to_vpp (s->vpp_evt_q, s->tx_fifo->master_session_index,
+ app_send_io_evt_to_vpp (s->vpp_evt_q,
+ s->tx_fifo->shr->master_session_index,
SESSION_IO_EVT_TX, SVM_Q_WAIT);
VDBG (0, "Migrated 0x%lx to thread %u 0x%lx", mp->handle,
- s->vpp_thread_index, mp->new_handle);
+ mp->vpp_thread_index, mp->new_handle);
}
static vcl_session_t *
vppcom_session_disconnect (u32 session_handle)
{
vcl_worker_t *wrk = vcl_worker_get_current ();
- svm_msg_q_t *vpp_evt_q;
vcl_session_t *session, *listen_session;
vcl_session_state_t state;
u64 vpp_handle;
if (state == VCL_STATE_VPP_CLOSING)
{
- vpp_evt_q = vcl_session_vpp_evt_q (wrk, session);
- vcl_send_session_disconnected_reply (vpp_evt_q, wrk->api_client_handle,
- vpp_handle, 0);
+ vcl_send_session_disconnected_reply (wrk, session, 0);
VDBG (1, "session %u [0x%llx]: sending disconnect REPLY...",
session->session_index, vpp_handle);
}
}
else if (session->session_state == VCL_STATE_DISCONNECT)
{
- vcl_send_session_reset_reply (vcl_session_vpp_evt_q (wrk, session),
- wrk->api_client_handle,
- session->vpp_handle, 0);
+ vcl_send_session_reset_reply (wrk, session, 0);
session->session_state = VCL_STATE_UPDATED;
}
return;
VDBG (0, "unknown handle 0x%llx", msg->handle);
return;
}
- if (vcl_segment_is_not_mounted (wrk, msg->segment_handle))
- {
- clib_warning ("segment for session %u is not mounted!",
- s->session_index);
- return;
- }
if (s->rx_fifo)
{
- s->rx_fifo = uword_to_pointer (msg->rx_fifo, svm_fifo_t *);
- s->tx_fifo = uword_to_pointer (msg->tx_fifo, svm_fifo_t *);
- s->rx_fifo->client_session_index = s->session_index;
- s->tx_fifo->client_session_index = s->session_index;
- s->rx_fifo->client_thread_index = wrk->wrk_index;
- s->tx_fifo->client_thread_index = wrk->wrk_index;
+ if (vcl_segment_attach_session (msg->segment_handle, msg->rx_fifo,
+ msg->tx_fifo, (uword) ~0, 0, s))
+ {
+ VDBG (0, "failed to attach fifos for %u", s->session_index);
+ return;
+ }
}
s->session_state = VCL_STATE_UPDATED;
(vcm->wrk_rpc_fn) (((session_app_wrk_rpc_msg_t *) data)->data);
}
+static void
+vcl_session_transport_attr_reply_handler (vcl_worker_t *wrk, void *data)
+{
+ session_transport_attr_reply_msg_t *mp;
+
+ if (!wrk->session_attr_op)
+ return;
+
+ mp = (session_transport_attr_reply_msg_t *) data;
+
+ wrk->session_attr_op_rv = mp->retval;
+ wrk->session_attr_op = 0;
+ wrk->session_attr_rv = mp->attr;
+}
+
static int
vcl_handle_mq_event (vcl_worker_t * wrk, session_event_t * e)
{
case SESSION_CTRL_EVT_APP_WRK_RPC:
vcl_worker_rpc_handler (wrk, e->data);
break;
+ case SESSION_CTRL_EVT_TRANSPORT_ATTR_REPLY:
+ vcl_session_transport_attr_reply_handler (wrk, e->data);
+ break;
default:
clib_warning ("unhandled %u", e->event_type);
}
}
void
-vcl_flush_mq_events (void)
+vcl_worker_flush_mq_events (vcl_worker_t *wrk)
{
- vcl_worker_t *wrk = vcl_worker_get_current ();
svm_msg_q_msg_t *msg;
session_event_t *e;
svm_msg_q_t *mq;
int i;
mq = wrk->app_event_queue;
- svm_msg_q_lock (mq);
vcl_mq_dequeue_batch (wrk, mq, ~0);
- svm_msg_q_unlock (mq);
for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
{
vcl_handle_pending_wrk_updates (wrk);
}
+void
+vcl_flush_mq_events (void)
+{
+ vcl_worker_flush_mq_events (vcl_worker_get_current ());
+}
+
static int
vppcom_session_unbind (u32 session_handle)
{
vcl_session_table_del_vpp_handle (wrk, accepted_msg->handle);
vcl_send_session_accepted_reply (session->vpp_evt_q,
accepted_msg->context,
- session->vpp_handle, -1);
+ accepted_msg->handle, -1);
}
clib_fifo_free (session->accept_evts_fifo);
current_wrk = vcl_worker_get_current ();
/* *INDENT-OFF* */
- pool_foreach (wrk, vcm->workers, ({
+ pool_foreach (wrk, vcm->workers) {
if (current_wrk != wrk)
vcl_worker_cleanup (wrk, 0 /* notify vpp */ );
- }));
+ }
/* *INDENT-ON* */
vcl_api_detach (current_wrk);
session->session_type = proto;
session->session_state = VCL_STATE_CLOSED;
session->vpp_handle = ~0;
+ session->ckpair_index = ~0;
session->is_dgram = vcl_proto_is_dgram (proto);
if (is_nonblocking)
s->vep.vep_sh, rv, vppcom_retval_str (rv));
next_sh = s->vep.next_sh;
}
- goto cleanup;
+ goto free_session;
}
if (s->flags & VCL_SESSION_F_IS_VEP_SESSION)
}
else if (s->session_state == VCL_STATE_DISCONNECT)
{
- svm_msg_q_t *mq = vcl_session_vpp_evt_q (wrk, s);
- vcl_send_session_reset_reply (mq, wrk->api_client_handle,
- s->vpp_handle, 0);
+ vcl_send_session_reset_reply (wrk, s, 0);
}
else if (s->session_state == VCL_STATE_DETACHED)
{
*proto = VPPCOM_PROTO_QUIC;
else if (!strcmp (proto_str, "quic"))
*proto = VPPCOM_PROTO_QUIC;
+ else if (!strcmp (proto_str, "DTLS"))
+ *proto = VPPCOM_PROTO_DTLS;
+ else if (!strcmp (proto_str, "dtls"))
+ *proto = VPPCOM_PROTO_DTLS;
else
return 1;
return 0;
vcl_session_t *listen_session = 0;
vcl_session_t *client_session = 0;
vcl_session_msg_t *evt;
- svm_msg_q_msg_t msg;
- session_event_t *e;
u8 is_nonblocking;
int rv;
+again:
+
listen_session = vcl_session_get_w_handle (wrk, listen_session_handle);
if (!listen_session)
return VPPCOM_EBADFD;
if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
return VPPCOM_EAGAIN;
- if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_WAIT, 0))
- return VPPCOM_EAGAIN;
-
- e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
- if (e->event_type != SESSION_CTRL_EVT_ACCEPTED)
- {
- vcl_handle_mq_event (wrk, e);
- svm_msg_q_free_msg (wrk->app_event_queue, &msg);
- continue;
- }
- clib_memcpy_fast (&accepted_msg, e->data, sizeof (accepted_msg));
- svm_msg_q_free_msg (wrk->app_event_queue, &msg);
- break;
+ svm_msg_q_wait (wrk->app_event_queue, SVM_MQ_WAIT_EMPTY);
+ vcl_worker_flush_mq_events (wrk);
+ goto again;
}
handle:
return rv;
}
-static u8
-vcl_is_rx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
-{
- return (e->event_type == SESSION_IO_EVT_RX && e->session_index == sid);
-}
-
static inline int
vppcom_session_read_internal (uint32_t session_handle, void *buf, int n,
u8 peek)
int rv, n_read = 0, is_nonblocking;
vcl_session_t *s = 0;
svm_fifo_t *rx_fifo;
- svm_msg_q_msg_t msg;
session_event_t *e;
svm_msg_q_t *mq;
u8 is_ct;
{
if (vcl_session_is_closing (s))
return vcl_session_closing_error (s);
- svm_fifo_unset_event (s->rx_fifo);
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
+ svm_fifo_unset_event (rx_fifo);
return VPPCOM_EWOULDBLOCK;
}
while (svm_fifo_is_empty_cons (rx_fifo))
if (vcl_session_is_closing (s))
return vcl_session_closing_error (s);
- svm_fifo_unset_event (s->rx_fifo);
- svm_msg_q_lock (mq);
- if (svm_msg_q_is_empty (mq))
- svm_msg_q_wait (mq);
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
+ svm_fifo_unset_event (rx_fifo);
- svm_msg_q_sub_w_lock (mq, &msg);
- e = svm_msg_q_msg_data (mq, &msg);
- svm_msg_q_unlock (mq);
- if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
- vcl_handle_mq_event (wrk, e);
- svm_msg_q_free_msg (mq, &msg);
+ svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
+ vcl_worker_flush_mq_events (wrk);
}
}
if (svm_fifo_is_empty_cons (rx_fifo))
{
- svm_fifo_unset_event (s->rx_fifo);
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
+ svm_fifo_unset_event (rx_fifo);
if (!svm_fifo_is_empty_cons (rx_fifo)
- && svm_fifo_set_event (s->rx_fifo) && is_nonblocking)
+ && svm_fifo_set_event (rx_fifo) && is_nonblocking)
{
vec_add2 (wrk->unhandled_evts_vector, e, 1);
e->event_type = SESSION_IO_EVT_RX;
e->session_index = s->session_index;
}
}
- else if (PREDICT_FALSE (rv < n))
+ else if (PREDICT_FALSE (rv < n && !s->is_dgram))
{
/* More data enqueued while reading. Try to drain it
- * or fill the buffer */
+ * or fill the buffer. Avoid doing that for dgrams */
buf += rv;
n -= rv;
goto read_again;
if (PREDICT_FALSE (svm_fifo_needs_deq_ntf (rx_fifo, n_read)))
{
svm_fifo_clear_deq_ntf (rx_fifo);
- app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo->master_session_index,
+ app_send_io_evt_to_vpp (s->vpp_evt_q,
+ s->rx_fifo->shr->master_session_index,
SESSION_IO_EVT_RX, SVM_Q_WAIT);
}
int n_read = 0, is_nonblocking;
vcl_session_t *s = 0;
svm_fifo_t *rx_fifo;
- svm_msg_q_msg_t msg;
- session_event_t *e;
svm_msg_q_t *mq;
u8 is_ct;
is_nonblocking = vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK);
is_ct = vcl_session_is_ct (s);
mq = wrk->app_event_queue;
- rx_fifo = s->rx_fifo;
+ rx_fifo = is_ct ? s->ct_rx_fifo : s->rx_fifo;
s->flags &= ~VCL_SESSION_F_HAS_RX_EVT;
- if (is_ct)
- svm_fifo_unset_event (s->rx_fifo);
-
if (svm_fifo_is_empty_cons (rx_fifo))
{
if (is_nonblocking)
{
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
svm_fifo_unset_event (rx_fifo);
return VPPCOM_EWOULDBLOCK;
}
if (vcl_session_is_closing (s))
return vcl_session_closing_error (s);
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
svm_fifo_unset_event (rx_fifo);
- svm_msg_q_lock (mq);
- if (svm_msg_q_is_empty (mq))
- svm_msg_q_wait (mq);
- svm_msg_q_sub_w_lock (mq, &msg);
- e = svm_msg_q_msg_data (mq, &msg);
- svm_msg_q_unlock (mq);
- if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
- vcl_handle_mq_event (wrk, e);
- svm_msg_q_free_msg (mq, &msg);
+ svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
+ vcl_worker_flush_mq_events (wrk);
}
}
if (svm_fifo_max_dequeue_cons (rx_fifo) == n_read)
{
- svm_fifo_unset_event (s->rx_fifo);
+ if (is_ct)
+ svm_fifo_unset_event (s->rx_fifo);
+ svm_fifo_unset_event (rx_fifo);
if (svm_fifo_max_dequeue_cons (rx_fifo) != n_read
- && svm_fifo_set_event (s->rx_fifo)
+ && svm_fifo_set_event (rx_fifo)
&& vcl_session_has_attr (s, VCL_SESS_ATTR_NONBLOCK))
{
session_event_t *e;
{
vcl_worker_t *wrk = vcl_worker_get_current ();
vcl_session_t *s;
+ u8 is_ct;
s = vcl_session_get_w_handle (wrk, session_handle);
if (PREDICT_FALSE (!s || (s->flags & VCL_SESSION_F_IS_VEP)))
return;
- svm_fifo_dequeue_drop (s->rx_fifo, n_bytes);
+ is_ct = vcl_session_is_ct (s);
+ svm_fifo_dequeue_drop (is_ct ? s->ct_rx_fifo : s->rx_fifo, n_bytes);
ASSERT (s->rx_bytes_pending < n_bytes);
s->rx_bytes_pending -= n_bytes;
}
-static u8
-vcl_is_tx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
-{
- return (e->event_type == SESSION_IO_EVT_TX && e->session_index == sid);
-}
-
always_inline u8
vcl_fifo_is_writeable (svm_fifo_t * f, u32 len, u8 is_dgram)
{
{
int n_write, is_nonblocking;
session_evt_type_t et;
- svm_msg_q_msg_t msg;
svm_fifo_t *tx_fifo;
- session_event_t *e;
svm_msg_q_t *mq;
u8 is_ct;
svm_fifo_add_want_deq_ntf (tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
if (vcl_session_is_closing (s))
return vcl_session_closing_error (s);
- svm_msg_q_lock (mq);
- if (svm_msg_q_is_empty (mq))
- svm_msg_q_wait (mq);
- svm_msg_q_sub_w_lock (mq, &msg);
- e = svm_msg_q_msg_data (mq, &msg);
- svm_msg_q_unlock (mq);
-
- if (!vcl_is_tx_evt_for_session (e, s->session_index, is_ct))
- vcl_handle_mq_event (wrk, e);
- svm_msg_q_free_msg (mq, &msg);
+ svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
+ vcl_worker_flush_mq_events (wrk);
}
}
0 /* do_evt */ , SVM_Q_WAIT);
if (svm_fifo_set_event (s->tx_fifo))
- app_send_io_evt_to_vpp (s->vpp_evt_q, s->tx_fifo->master_session_index,
- et, SVM_Q_WAIT);
+ app_send_io_evt_to_vpp (
+ s->vpp_evt_q, s->tx_fifo->shr->master_session_index, et, SVM_Q_WAIT);
/* The underlying fifo segment can run out of memory */
if (PREDICT_FALSE (n_write < 0))
session_event_t *e;
u32 i;
- svm_msg_q_lock (mq);
if (svm_msg_q_is_empty (mq))
{
if (*bits_set)
- {
- svm_msg_q_unlock (mq);
- return 0;
- }
+ return 0;
if (!time_to_wait)
- {
- svm_msg_q_unlock (mq);
- return 0;
- }
+ return 0;
else if (time_to_wait < 0)
- {
- svm_msg_q_wait (mq);
- }
+ svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
else
{
if (svm_msg_q_timedwait (mq, time_to_wait))
- {
- svm_msg_q_unlock (mq);
- return 0;
- }
+ return 0;
}
}
vcl_mq_dequeue_batch (wrk, mq, ~0);
- svm_msg_q_unlock (mq);
for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
{
{
u32 sid, minbits = clib_max (n_bits, BITS (uword)), bits_set = 0;
vcl_worker_t *wrk = vcl_worker_get_current ();
- vcl_session_t *session = 0;
+ vcl_session_t *s = 0;
int i;
if (n_bits && read_map)
if (!write_map)
goto check_rd;
- /* *INDENT-OFF* */
- clib_bitmap_foreach (sid, wrk->wr_bitmap, ({
- if (!(session = vcl_session_get (wrk, sid)))
- {
- clib_bitmap_set_no_check ((uword*)write_map, sid, 1);
- bits_set++;
- continue;
- }
+ clib_bitmap_foreach (sid, wrk->wr_bitmap)
+ {
+ if (!(s = vcl_session_get (wrk, sid)))
+ {
+ clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
+ bits_set++;
+ continue;
+ }
- if (vcl_session_write_ready (session))
- {
- clib_bitmap_set_no_check ((uword*)write_map, sid, 1);
- bits_set++;
- }
- else
- svm_fifo_add_want_deq_ntf (session->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
- }));
+ if (vcl_session_write_ready (s))
+ {
+ clib_bitmap_set_no_check ((uword *) write_map, sid, 1);
+ bits_set++;
+ }
+ else
+ {
+ svm_fifo_t *txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
+ svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF);
+ }
+ }
check_rd:
if (!read_map)
goto check_mq;
- clib_bitmap_foreach (sid, wrk->rd_bitmap, ({
- if (!(session = vcl_session_get (wrk, sid)))
- {
- clib_bitmap_set_no_check ((uword*)read_map, sid, 1);
- bits_set++;
- continue;
- }
-
- if (vcl_session_read_ready (session))
- {
- clib_bitmap_set_no_check ((uword*)read_map, sid, 1);
- bits_set++;
- }
- }));
- /* *INDENT-ON* */
+ clib_bitmap_foreach (sid, wrk->rd_bitmap)
+ {
+ if (!(s = vcl_session_get (wrk, sid)))
+ {
+ clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
+ bits_set++;
+ continue;
+ }
+
+ if (vcl_session_read_ready (s))
+ {
+ clib_bitmap_set_no_check ((uword *) read_map, sid, 1);
+ bits_set++;
+ }
+ }
check_mq:
s->vep.et_mask = VEP_DEFAULT_ET_MASK;
s->vep.ev = *event;
txf = vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo;
- if (event->events & EPOLLOUT)
- svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
- else
- svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
+ if (txf)
+ {
+ if (event->events & EPOLLOUT)
+ svm_fifo_add_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
+ else
+ svm_fifo_del_want_deq_ntf (txf, SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
+ }
VDBG (1, "EPOLL_CTL_MOD: vep_sh %u, sh %u, events 0x%x, data 0x%llx!",
vep_handle, session_handle, event->events, event->data.u64);
break;
if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
goto handle_dequeued;
- svm_msg_q_lock (mq);
if (svm_msg_q_is_empty (mq))
{
if (!wait_for_time)
- {
- svm_msg_q_unlock (mq);
- return 0;
- }
+ return 0;
else if (wait_for_time < 0)
- {
- svm_msg_q_wait (mq);
- }
+ svm_msg_q_wait (mq, SVM_MQ_WAIT_EMPTY);
else
{
if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
- {
- svm_msg_q_unlock (mq);
- return 0;
- }
+ return 0;
}
}
ASSERT (maxevents > *num_ev);
vcl_mq_dequeue_batch (wrk, mq, ~0);
- svm_msg_q_unlock (mq);
handle_dequeued:
for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
vppcom_epoll_wait_eventfd (vcl_worker_t * wrk, struct epoll_event *events,
int maxevents, u32 n_evts, double wait_for_time)
{
- vcl_mq_evt_conn_t *mqc;
+ double wait = 0, start = 0, now;
int __clib_unused n_read;
+ vcl_mq_evt_conn_t *mqc;
int n_mq_evts, i;
u64 buf;
vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
-again:
- n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
- vec_len (wrk->mq_events), wait_for_time);
- for (i = 0; i < n_mq_evts; i++)
+ if (!n_evts)
{
- mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
- n_read = read (mqc->mq_fd, &buf, sizeof (buf));
- vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0, &n_evts);
+ wait = wait_for_time;
+ start = clib_time_now (&wrk->clib_time);
+ }
+
+ do
+ {
+ n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
+ vec_len (wrk->mq_events), wait);
+ if (n_mq_evts < 0)
+ {
+ VDBG (0, "epoll_wait error %u", errno);
+ return n_evts;
+ }
+
+ for (i = 0; i < n_mq_evts; i++)
+ {
+ mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
+ n_read = read (mqc->mq_fd, &buf, sizeof (buf));
+ vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0,
+ &n_evts);
+ }
+
+ if (n_evts)
+ return n_evts;
+ if (wait == -1)
+ continue;
+
+ now = clib_time_now (&wrk->clib_time);
+ wait -= (now - start) * 1e3;
+ start = now;
}
- if (!n_evts && n_mq_evts > 0)
- goto again;
+ while (wait > 0);
- return (int) n_evts;
+ return 0;
}
int
}
vec_reset_length (wrk->unhandled_evts_vector);
}
+ /* Request to only drain unhandled */
+ if ((int) wait_for_time == -2)
+ return n_evts;
if (vcm->cfg.use_mq_eventfd)
return vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
void *buffer, uint32_t * buflen)
{
vcl_worker_t *wrk = vcl_worker_get_current ();
- vcl_session_t *session;
- int rv = VPPCOM_OK;
u32 *flags = buffer, tmp_flags = 0;
vppcom_endpt_t *ep = buffer;
+ transport_endpt_attr_t tea;
+ vcl_session_t *session;
+ int rv = VPPCOM_OK;
session = vcl_session_get_w_handle (wrk, session_handle);
if (!session)
break;
case VPPCOM_ATTR_GET_TCP_USER_MSS:
- if (buffer && buflen && (*buflen >= sizeof (u32)))
+ if (!(buffer && buflen && (*buflen >= sizeof (u32))))
{
- /* VPP-TBD */
- *(u32 *) buffer = session->user_mss;
- *buflen = sizeof (int);
+ rv = VPPCOM_EINVAL;
+ break;
+ }
- VDBG (2, "VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d, #VPP-TBD#",
- *(int *) buffer, *buflen);
+ tea.type = TRANSPORT_ENDPT_ATTR_MSS;
+ tea.mss = *(u32 *) buffer;
+ if (vcl_session_transport_attr (wrk, session, 1 /* is_get */, &tea))
+ rv = VPPCOM_ENOPROTOOPT;
+
+ if (!rv)
+ {
+ *(u32 *) buffer = tea.mss;
+ *buflen = sizeof (int);
}
- else
- rv = VPPCOM_EINVAL;
+
+ VDBG (2, "VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d", *(int *) buffer,
+ *buflen);
break;
case VPPCOM_ATTR_SET_TCP_USER_MSS:
- if (buffer && buflen && (*buflen == sizeof (u32)))
+ if (!(buffer && buflen && (*buflen == sizeof (u32))))
{
- /* VPP-TBD */
- session->user_mss = *(u32 *) buffer;
-
- VDBG (2, "VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d, #VPP-TBD#",
- session->user_mss, *buflen);
+ rv = VPPCOM_EINVAL;
+ break;
}
- else
- rv = VPPCOM_EINVAL;
+
+ tea.type = TRANSPORT_ENDPT_ATTR_MSS;
+ tea.mss = *(u32 *) buffer;
+ if (vcl_session_transport_attr (wrk, session, 0 /* is_get */, &tea))
+ rv = VPPCOM_ENOPROTOOPT;
+
+ VDBG (2, "VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d", tea.mss,
+ *buflen);
break;
case VPPCOM_ATTR_SET_SHUT:
session->flags |= VCL_SESSION_F_CONNECTED;
break;
+ case VPPCOM_ATTR_SET_CKPAIR:
+ if (!(buffer && buflen && (*buflen == sizeof (int))) ||
+ !vcl_session_has_crypto (session))
+ {
+ rv = VPPCOM_EINVAL;
+ break;
+ }
+ session->ckpair_index = *(uint32_t *) buffer;
+ break;
+
+ case VPPCOM_ATTR_SET_VRF:
+ if (!(buffer && buflen && (*buflen == sizeof (u32))))
+ {
+ rv = VPPCOM_EINVAL;
+ break;
+ }
+ session->vrf = *(u32 *) buffer;
+ break;
+
+ case VPPCOM_ATTR_GET_VRF:
+ if (!(buffer && buflen && (*buflen >= sizeof (u32))))
+ {
+ rv = VPPCOM_EINVAL;
+ break;
+ }
+ *(u32 *) buffer = session->vrf;
+ *buflen = sizeof (u32);
+ break;
+
+ case VPPCOM_ATTR_GET_DOMAIN:
+ if (!(buffer && buflen && (*buflen >= sizeof (int))))
+ {
+ rv = VPPCOM_EINVAL;
+ break;
+ }
+
+ if (session->transport.is_ip4)
+ *(int *) buffer = AF_INET;
+ else
+ *(int *) buffer = AF_INET6;
+ *buflen = sizeof (int);
+
+ VDBG (2, "VPPCOM_ATTR_GET_DOMAIN: %d, buflen %u", *(int *) buffer,
+ *buflen);
+ break;
+
default:
rv = VPPCOM_EINVAL;
break;
case VPPCOM_PROTO_QUIC:
proto_str = "QUIC";
break;
+ case VPPCOM_PROTO_DTLS:
+ proto_str = "DTLS";
+ break;
default:
proto_str = "UNKNOWN";
break;
return st;
}
+int
+vppcom_add_cert_key_pair (vppcom_cert_key_pair_t *ckpair)
+{
+ if (vcm->cfg.vpp_app_socket_api)
+ {
+ clib_warning ("not supported");
+ return VPPCOM_EINVAL;
+ }
+ return vcl_bapi_add_cert_key_pair (ckpair);
+}
+
+int
+vppcom_del_cert_key_pair (uint32_t ckpair_index)
+{
+ if (vcm->cfg.vpp_app_socket_api)
+ {
+ clib_warning ("not supported");
+ return VPPCOM_EINVAL;
+ }
+ return vcl_bapi_del_cert_key_pair (ckpair_index);
+}
+
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff