f64 timeout;
ASSERT (!wrk->session_attr_op);
+ mq = s->vpp_evt_q;
+ if (PREDICT_FALSE (!mq))
+ {
+ /* FIXME: attribute should be stored and sent once session is
+ * bound/connected to vpp */
+ return 0;
+ }
+
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->segment_handle, mp->server_rx_fifo, mp->server_tx_fifo,
mp->vpp_event_queue_address, mp->mq_index, 0, session))
{
- VDBG (0, "failed to attach fifos for %u", session->session_index);
+ VDBG (0, "session %u [0x%llx]: failed to attach fifos",
+ session->session_index, mp->handle);
goto error;
}
session->listener_index = listen_session->session_index;
listen_session->n_accepted_sessions++;
- VDBG (1,
- "session %u [0x%llx]: client accept request from %s address %U"
- " port %d queue %p!",
- session->session_index, mp->handle, mp->rmt.is_ip4 ? "IPv4" : "IPv6",
- vcl_format_ip46_address, &mp->rmt.ip,
- mp->rmt.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
- clib_net_to_host_u16 (mp->rmt.port), session->vpp_evt_q);
vcl_evt (VCL_EVT_ACCEPT, session, listen_session, session_index);
vcl_send_session_accepted_reply (session->vpp_evt_q, mp->context,
if (mp->retval)
{
- VDBG (0, "session index %u: connect failed! %U", session_index,
+ VDBG (0, "session %u: connect failed! %U", session_index,
format_session_error, mp->retval);
session->session_state = VCL_STATE_DETACHED;
session->vpp_handle = VCL_INVALID_SESSION_HANDLE;
+ session->vpp_error = mp->retval;
return session_index;
}
mp->segment_handle, mp->server_rx_fifo, mp->server_tx_fifo,
mp->vpp_event_queue_address, mp->mq_index, 0, session))
{
- VDBG (0, "failed to attach fifos for %u", session->session_index);
+ VDBG (0, "session %u [0x%llx]: failed to attach fifos",
+ session->session_index, session->vpp_handle);
session->session_state = VCL_STATE_UPDATED;
vcl_send_session_disconnect (wrk, session);
return session_index;
mp->ct_tx_fifo, (uword) ~0, ~0, 1,
session))
{
- VDBG (0, "failed to attach ct fifos for %u", session->session_index);
+ VDBG (0, "session %u [0x%llx]: failed to attach ct fifos",
+ session->session_index, session->vpp_handle);
session->session_state = VCL_STATE_UPDATED;
vcl_send_session_disconnect (wrk, session);
return session_index;
else
session->session_state = VCL_STATE_READY;
- VDBG (1, "session %u [0x%llx] connected! rx_fifo %p, refcnt %d, tx_fifo %p,"
- " refcnt %d", session_index, mp->handle, session->rx_fifo,
- session->rx_fifo->refcnt, session->tx_fifo, session->tx_fifo->refcnt);
+ VDBG (0, "session %u [0x%llx] connected local: %U:%u remote %U:%u",
+ session->session_index, session->vpp_handle, vcl_format_ip46_address,
+ &session->transport.lcl_ip,
+ session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+ clib_net_to_host_u16 (session->transport.lcl_port),
+ vcl_format_ip46_address, &session->transport.rmt_ip,
+ session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+ clib_net_to_host_u16 (session->transport.rmt_port));
return session_index;
}
if (session->session_state != VCL_STATE_CLOSED)
session->session_state = VCL_STATE_DISCONNECT;
- VDBG (0, "reset session %u [0x%llx]", sid, reset_msg->handle);
+
+ session->flags |= (VCL_SESSION_F_RD_SHUTDOWN | VCL_SESSION_F_WR_SHUTDOWN);
+ VDBG (0, "session %u [0x%llx]: reset", sid, reset_msg->handle);
return sid;
}
}
else
{
- VDBG (0, "ERROR: session %u [0x%llx]: Invalid session index!",
- sid, mp->handle);
+ VDBG (0, "session %u [0x%llx]: Invalid session index!", sid,
+ mp->handle);
return VCL_INVALID_SESSION_INDEX;
}
}
mp->tx_fifo, mp->vpp_evt_q, mp->mq_index,
0, session))
{
- VDBG (0, "failed to attach fifos for %u", session->session_index);
+ VDBG (0, "session %u [0x%llx]: failed to attach fifos",
+ session->session_index, session->vpp_handle);
session->session_state = VCL_STATE_DETACHED;
return VCL_INVALID_SESSION_INDEX;
}
session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
if (!session)
{
- VDBG (0, "request to disconnect unknown handle 0x%llx", msg->handle);
+ VWRN ("request to disconnect unknown handle 0x%llx", msg->handle);
return 0;
}
vpp_handle = session->vpp_handle;
state = session->session_state;
- VDBG (1, "session %u [0x%llx] state 0x%x (%s)", session->session_index,
- vpp_handle, state, vcl_session_state_str (state));
+ VDBG (1, "session %u [0x%llx]: disconnecting state (%s)",
+ session->session_index, vpp_handle, vcl_session_state_str (state));
if (PREDICT_FALSE (state == VCL_STATE_LISTEN))
{
if (PREDICT_FALSE (!session->vpp_evt_q))
return VPPCOM_OK;
- VDBG (1, "session %u [0x%llx]: sending disconnect...",
+ VDBG (1, "session %u [0x%llx]: sending disconnect",
session->session_index, vpp_handle);
vcl_send_session_disconnect (wrk, session);
}
if (session->listener_index != VCL_INVALID_SESSION_INDEX)
{
listen_session = vcl_session_get (wrk, session->listener_index);
- listen_session->n_accepted_sessions--;
+ if (listen_session)
+ listen_session->n_accepted_sessions--;
}
return VPPCOM_OK;
session = vcl_session_get_w_vpp_handle (wrk, msg->handle);
if (!session)
{
- VDBG (0, "disconnect confirmed for unknown handle 0x%llx", msg->handle);
+ VWRN ("disconnect confirmed for unknown handle 0x%llx", msg->handle);
return;
}
/* App did not close the connection yet so don't free it. */
if (session->session_state != VCL_STATE_CLOSED)
{
- VDBG (0, "app did not close session %d", session->session_index);
+ VDBG (0, "session %u: app did not close", session->session_index);
session->session_state = VCL_STATE_DETACHED;
session->vpp_handle = VCL_INVALID_SESSION_HANDLE;
return;
{
s->flags |= VCL_SESSION_F_PENDING_DISCONNECT;
s->session_state = VCL_STATE_DISCONNECT;
+ s->flags |= (VCL_SESSION_F_RD_SHUTDOWN | VCL_SESSION_F_WR_SHUTDOWN);
vec_add2 (wrk->unhandled_evts_vector, ecpy, 1);
*ecpy = *e;
ecpy->postponed = 1;
return vcl_bapi_attach ();
}
+int
+vcl_is_first_reattach_to_execute ()
+{
+ if (vcm->reattach_count == 0)
+ return 1;
+
+ return 0;
+}
+
+void
+vcl_set_reattach_counter ()
+{
+ ++vcm->reattach_count;
+
+ if (vcm->reattach_count == vec_len (vcm->workers))
+ vcm->reattach_count = 0;
+}
+
+/**
+ * Reattach vcl to vpp after it has previously been disconnected.
+ *
+ * The logic should be:
+ * - first worker to hit `vcl_api_retry_attach` should attach to vpp,
+ * to reproduce the `vcl_api_attach` in `vppcom_app_create`.
+ * - the rest of the workers should `reproduce vcl_worker_register_with_vpp`
+ * from `vppcom_worker_register` since they were already allocated.
+ */
+
+static void
+vcl_api_retry_attach (vcl_worker_t *wrk)
+{
+ vcl_session_t *s;
+
+ clib_spinlock_lock (&vcm->workers_lock);
+ if (vcl_is_first_reattach_to_execute ())
+ {
+ if (vcl_api_attach ())
+ {
+ clib_spinlock_unlock (&vcm->workers_lock);
+ return;
+ }
+ vcl_set_reattach_counter ();
+ clib_spinlock_unlock (&vcm->workers_lock);
+ }
+ else
+ {
+ vcl_set_reattach_counter ();
+ clib_spinlock_unlock (&vcm->workers_lock);
+ vcl_worker_register_with_vpp ();
+ }
+
+ /* Treat listeners as configuration that needs to be re-added to vpp */
+ pool_foreach (s, wrk->sessions)
+ {
+ if (s->flags & VCL_SESSION_F_IS_VEP)
+ continue;
+ if (s->session_state == VCL_STATE_LISTEN_NO_MQ)
+ vppcom_session_listen (vcl_session_handle (s), 10);
+ else
+ VDBG (0, "internal error: unexpected state %d", s->session_state);
+ }
+}
+
+static void
+vcl_api_handle_disconnect (vcl_worker_t *wrk)
+{
+ wrk->api_client_handle = ~0;
+ vcl_worker_detach_sessions (wrk);
+}
+
static void
vcl_api_detach (vcl_worker_t * wrk)
{
+ if (wrk->api_client_handle == ~0)
+ return;
+
vcl_send_app_detach (wrk);
if (vcm->cfg.vpp_app_socket_api)
vcl_worker_alloc_and_init ();
if ((rv = vcl_api_attach ()))
- return rv;
+ {
+ vppcom_app_destroy ();
+ return rv;
+ }
VDBG (0, "app_name '%s', my_client_index %d (0x%x)", app_name,
vcm->workers[0].api_client_handle, vcm->workers[0].api_client_handle);
vcl_api_detach (current_wrk);
vcl_worker_cleanup (current_wrk, 0 /* notify vpp */ );
+ vcl_set_worker_index (~0);
vcl_elog_stop (vcm);
session->session_state = VCL_STATE_CLOSED;
session->vpp_handle = ~0;
session->is_dgram = vcl_proto_is_dgram (proto);
+ session->vpp_error = SESSION_E_NONE;
if (is_nonblocking)
vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
{
- VDBG (0, "ERROR: cannot connect epoll session %u!",
- session->session_index);
+ VWRN ("cannot connect epoll session %u!", session->session_index);
return VPPCOM_EBADFD;
}
if (PREDICT_FALSE (vcl_session_is_ready (session)))
{
VDBG (0,
- "session handle %u [0x%llx]: session already "
- "connected to %s %U port %d proto %s, state 0x%x (%s)",
- session_handle, session->vpp_handle,
- session->transport.is_ip4 ? "IPv4" : "IPv6",
+ "session %u [0x%llx]: already connected to %U:%d proto %s,"
+ " state (%s)",
+ session->session_index, session->vpp_handle,
vcl_format_ip46_address, &session->transport.rmt_ip,
session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
clib_net_to_host_u16 (session->transport.rmt_port),
- vppcom_proto_str (session->session_type), session->session_state,
+ vppcom_proto_str (session->session_type),
vcl_session_state_str (session->session_state));
return VPPCOM_OK;
}
session->parent_handle = VCL_INVALID_SESSION_HANDLE;
session->flags |= VCL_SESSION_F_CONNECTED;
- VDBG (0,
- "session handle %u (%s): connecting to peer %s %U "
- "port %d proto %s",
- session_handle, vcl_session_state_str (session->session_state),
- session->transport.is_ip4 ? "IPv4" : "IPv6", vcl_format_ip46_address,
+ VDBG (0, "session %u: connecting to peer %U:%d proto %s",
+ session->session_index, vcl_format_ip46_address,
&session->transport.rmt_ip,
session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
clib_net_to_host_u16 (session->transport.rmt_port),
}
n_read = svm_fifo_segments (rx_fifo, s->rx_bytes_pending,
- (svm_fifo_seg_t *) ds, n_segments, max_bytes);
+ (svm_fifo_seg_t *) ds, &n_segments, max_bytes);
if (n_read < 0)
return VPPCOM_EAGAIN;
}
always_inline int
-vppcom_session_write_inline (vcl_worker_t * wrk, vcl_session_t * s, void *buf,
- size_t n, u8 is_flush, u8 is_dgram)
+vppcom_session_write_inline (vcl_worker_t *wrk, vcl_session_t *s, void *buf,
+ size_t n, u16 gso_size, u8 is_flush, u8 is_dgram)
{
int n_write, is_nonblocking;
session_evt_type_t et;
et = SESSION_IO_EVT_TX_FLUSH;
if (is_dgram)
- n_write = app_send_dgram_raw (tx_fifo, &s->transport,
- s->vpp_evt_q, buf, n, et,
- 0 /* do_evt */ , SVM_Q_WAIT);
+ n_write =
+ app_send_dgram_raw_gso (tx_fifo, &s->transport, s->vpp_evt_q, buf, n,
+ gso_size, et, 0 /* do_evt */, SVM_Q_WAIT);
else
n_write = app_send_stream_raw (tx_fifo, s->vpp_evt_q, buf, n, et,
0 /* do_evt */ , SVM_Q_WAIT);
if (PREDICT_FALSE (!s))
return VPPCOM_EBADFD;
- return vppcom_session_write_inline (wrk, s, buf, n,
- 0 /* is_flush */ , s->is_dgram ? 1 : 0);
+ return vppcom_session_write_inline (wrk, s, buf, n, 0, 0 /* is_flush */,
+ s->is_dgram ? 1 : 0);
}
int
if (PREDICT_FALSE (!s))
return VPPCOM_EBADFD;
- return vppcom_session_write_inline (wrk, s, buf, n,
- 1 /* is_flush */ , s->is_dgram ? 1 : 0);
+ return vppcom_session_write_inline (wrk, s, buf, n, 0, 1 /* is_flush */,
+ s->is_dgram ? 1 : 0);
}
#define vcl_fifo_rx_evt_valid_or_break(_s) \
int n_mq_evts, i;
u64 buf;
+ if (PREDICT_FALSE (wrk->api_client_handle == ~0))
+ {
+ vcl_api_retry_attach (wrk);
+ return 0;
+ }
+
vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
vec_len (wrk->mq_events), time_to_wait);
for (i = 0; i < n_mq_evts; i++)
{
+ if (PREDICT_FALSE (wrk->mq_events[i].data.u32 == ~0))
+ {
+ vcl_api_handle_disconnect (wrk);
+ continue;
+ }
+
mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
n_read = read (mqc->mq_fd, &buf, sizeof (buf));
vcl_select_handle_mq (wrk, mqc->mq, n_bits, read_map, write_map,
/* Generate EPOLLOUT because there's no connected event */
if (!(EPOLLOUT & session_events))
break;
+ /* We didn't have a fifo when the event was added */
+ svm_fifo_add_want_deq_ntf (
+ (vcl_session_is_ct (s) ? s->ct_tx_fifo : s->tx_fifo),
+ SVM_FIFO_WANT_DEQ_NOTIF_IF_FULL);
add_event = 1;
events[*num_ev].events = EPOLLOUT;
session_evt_data = s->vep.ev.data.u64;
if (vcl_session_is_closed (s) ||
!(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
{
- if (s->flags & VCL_SESSION_F_PENDING_FREE)
+ if (s && (s->flags & VCL_SESSION_F_PENDING_FREE))
vcl_session_free (wrk, s);
break;
}
if (vcl_session_is_closed (s) ||
!(s->flags & VCL_SESSION_F_IS_VEP_SESSION))
{
- if (s->flags & VCL_SESSION_F_PENDING_FREE)
+ if (s && (s->flags & VCL_SESSION_F_PENDING_FREE))
vcl_session_free (wrk, s);
break;
}
session_events = s->vep.ev.events;
add_event = 1;
- events[*num_ev].events = EPOLLHUP | EPOLLRDHUP;
+ events[*num_ev].events = EPOLLERR | EPOLLHUP;
+ if ((EPOLLRDHUP & session_events) &&
+ (s->flags & VCL_SESSION_F_RD_SHUTDOWN))
+ {
+ events[*num_ev].events |= EPOLLRDHUP;
+ }
+ if ((EPOLLIN & session_events) && (s->flags & VCL_SESSION_F_RD_SHUTDOWN))
+ {
+ events[*num_ev].events |= EPOLLIN;
+ }
session_evt_data = s->vep.ev.data.u64;
break;
case SESSION_CTRL_EVT_UNLISTEN_REPLY:
double end = -1;
u64 buf;
+ if (PREDICT_FALSE (wrk->api_client_handle == ~0))
+ {
+ vcl_api_retry_attach (wrk);
+ return n_evts;
+ }
+
vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
if (!n_evts)
{
for (i = 0; i < n_mq_evts; i++)
{
+ if (PREDICT_FALSE (wrk->mq_events[i].data.u32 == ~0))
+ {
+ /* api socket was closed */
+ vcl_api_handle_disconnect (wrk);
+ continue;
+ }
+
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,
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))))
{
{
vcl_worker_t *wrk = vcl_worker_get_current ();
vcl_session_t *s;
+ u16 gso_size = 0;
s = vcl_session_get_w_handle (wrk, session_handle);
if (PREDICT_FALSE (!s))
s->transport.rmt_port = ep->port;
vcl_ip_copy_from_ep (&s->transport.rmt_ip, ep);
+ vppcom_endpt_tlv_t *p_app_data = &ep->app_data;
+
+ if (p_app_data && (p_app_data->data_type == VCL_UDP_SEGMENT))
+ {
+ gso_size = p_app_data->value;
+ }
/* Session not connected/bound in vpp. Create it by 'connecting' it */
if (PREDICT_FALSE (s->session_state == VCL_STATE_CLOSED))
{
VDBG (2, "handling flags 0x%u (%d) not implemented yet.", flags, flags);
}
- return (vppcom_session_write_inline (wrk, s, buffer, buflen, 1,
+ return (vppcom_session_write_inline (wrk, s, buffer, buflen, gso_size, 1,
s->is_dgram ? 1 : 0));
}
st = "VPPCOM_ETIMEDOUT";
break;
+ case VPPCOM_EADDRINUSE:
+ st = "VPPCOM_EADDRINUSE";
+ break;
+
default:
st = "UNKNOWN_STATE";
break;
return vcl_bapi_del_cert_key_pair (ckpair_index);
}
+int
+vppcom_session_get_error (uint32_t session_handle)
+{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vcl_session_t *session = 0;
+
+ session = vcl_session_get_w_handle (wrk, session_handle);
+ if (!session)
+ return VPPCOM_EBADFD;
+
+ if (PREDICT_FALSE (session->flags & VCL_SESSION_F_IS_VEP))
+ {
+ VWRN ("epoll session %u! will not have connect", session->session_index);
+ return VPPCOM_EBADFD;
+ }
+
+ if (session->vpp_error == SESSION_E_PORTINUSE)
+ return VPPCOM_EADDRINUSE;
+ else if (session->vpp_error == SESSION_E_REFUSED)
+ return VPPCOM_ECONNREFUSED;
+ else if (session->vpp_error != SESSION_E_NONE)
+ return VPPCOM_EFAULT;
+ else
+ return VPPCOM_OK;
+}
+
+int
+vppcom_worker_is_detached (void)
+{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+
+ if (!vcm->cfg.use_mq_eventfd)
+ return VPPCOM_ENOTSUP;
+
+ return wrk->api_client_handle == ~0;
+}
+
/*
* fd.io coding-style-patch-verification: ON
*