net/vpp: prepare vpp 19.01 to move to 19.04

No functional changes done, just reordering for next patch in series.

Change-Id: I32022fddffbc7b00eeecb29a2fcbaa85fbf2e99f
Signed-off-by: Tomasz Kulasek <tomaszx.kulasek@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/462473
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
This commit is contained in:
Tomasz Kulasek 2019-07-18 14:14:16 +02:00 committed by Jim Harris
parent 093bc3390a
commit bee1130c03

View File

@ -141,56 +141,6 @@ struct spdk_vpp_sock_group_impl {
#define __vpp_session(sock) ((struct spdk_vpp_session *)sock)
#define __vpp_group_impl(group) ((struct spdk_vpp_sock_group_impl *)group)
static int
vpp_queue_poller(void *ctx)
{
uword msg;
if (g_svm.vl_output_queue->cursize > 0 &&
!svm_queue_sub_raw(g_svm.vl_output_queue, (u8 *)&msg)) {
vl_msg_api_handler((void *)msg);
}
return 0;
}
static int
app_queue_poller(void *ctx)
{
svm_msg_q_msg_t msg;
if (!svm_msg_q_is_empty(g_svm.app_event_queue)) {
svm_msg_q_sub(g_svm.app_event_queue, &msg, SVM_Q_WAIT, 0);
svm_msg_q_free_msg(g_svm.app_event_queue, &msg);
}
return 0;
}
/* This is required until sock.c API changes to asynchronous */
static int
_wait_for_session_state_change(struct spdk_vpp_session *session, enum spdk_vpp_session_state state)
{
time_t start = time(NULL);
while (time(NULL) - start < 10) {
if (session->app_session.session_state == VPP_SESSION_STATE_FAILED) {
errno = EADDRNOTAVAIL;
return -1;
}
if (session->app_session.session_state == state) {
errno = 0;
return 0;
}
if (spdk_get_thread() == g_svm.init_thread) {
usleep(100000);
app_queue_poller(NULL);
vpp_queue_poller(NULL);
}
}
/* timeout */
errno = ETIMEDOUT;
return -1;
}
/******************************************************************************
* Session management
*/
@ -331,256 +281,7 @@ enum spdk_vpp_create_type {
};
/******************************************************************************
* Connect
*/
static void
vl_api_connect_session_reply_t_handler(vl_api_connect_session_reply_t *mp)
{
struct spdk_vpp_session *session;
svm_fifo_t *rx_fifo, *tx_fifo;
session = _spdk_vpp_session_get(mp->context);
if (session == NULL) {
return;
}
if (mp->retval) {
SPDK_ERRLOG("Connection failed (%d).\n", ntohl(mp->retval));
session->app_session.session_state = VPP_SESSION_STATE_FAILED;
return;
}
session->app_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 *);
rx_fifo->client_session_index = session->id;
tx_fifo = uword_to_pointer(mp->server_tx_fifo, svm_fifo_t *);
tx_fifo->client_session_index = session->id;
session->app_session.rx_fifo = rx_fifo;
session->app_session.tx_fifo = tx_fifo;
session->handle = mp->handle;
/* Set lcl addr */
session->app_session.transport.is_ip4 = mp->is_ip4;
memcpy(&session->app_session.transport.lcl_ip, mp->lcl_ip, sizeof(mp->lcl_ip));
session->app_session.transport.lcl_port = mp->lcl_port;
session->app_session.session_state = VPP_SESSION_STATE_READY;
}
static int
_spdk_vpp_session_connect(struct spdk_vpp_session *session)
{
vl_api_connect_sock_t *cmp;
cmp = vl_msg_api_alloc(sizeof(*cmp));
if (cmp == NULL) {
return -ENOMEM;
}
memset(cmp, 0, sizeof(*cmp));
cmp->_vl_msg_id = ntohs(VL_API_CONNECT_SOCK);
cmp->client_index = g_svm.my_client_index;
cmp->context = session->id;
cmp->vrf = 0 /* VPPCOM_VRF_DEFAULT */;
cmp->is_ip4 = (session->app_session.transport.is_ip4);
memcpy(cmp->ip, &session->app_session.transport.rmt_ip, sizeof(cmp->ip));
cmp->port = session->app_session.transport.rmt_port;
cmp->proto = TRANSPORT_PROTO_TCP;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&cmp);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_READY);
}
static void
vl_api_disconnect_session_reply_t_handler(vl_api_disconnect_session_reply_t *mp)
{
struct spdk_vpp_session *session;
if (mp->retval) {
SPDK_ERRLOG("Disconnecting session failed (%d).\n", ntohl(mp->retval));
return;
}
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Session disconnected %p (%d)\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_CLOSE;
pthread_mutex_unlock(&g_svm.session_get_lock);
}
static void
vl_api_disconnect_session_t_handler(vl_api_disconnect_session_t *mp)
{
struct spdk_vpp_session *session = 0;
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Disconnect session %p (%d) handler\n", session, session->id);
/* We need to postpone session deletion to inform upper layer */
session->app_session.session_state = VPP_SESSION_STATE_DISCONNECT;
pthread_mutex_unlock(&g_svm.session_get_lock);
}
static int
_spdk_vpp_session_disconnect(struct spdk_vpp_session *session)
{
int rv = 0;
vl_api_disconnect_session_t *dmp;
vl_api_disconnect_session_reply_t *rmp;
if (session->app_session.session_state == VPP_SESSION_STATE_DISCONNECT) {
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Session is already in disconnecting state %p (%d)\n",
session, session->id);
rmp = vl_msg_api_alloc(sizeof(*rmp));
if (rmp == NULL) {
return -ENOMEM;
}
memset(rmp, 0, sizeof(*rmp));
rmp->_vl_msg_id = ntohs(VL_API_DISCONNECT_SESSION_REPLY);
rmp->retval = rv;
rmp->handle = session->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&rmp);
return 0;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Disconnect session %p (%d)\n", session, session->id);
dmp = vl_msg_api_alloc(sizeof(*dmp));
if (dmp == NULL) {
return -ENOMEM;
}
memset(dmp, 0, sizeof(*dmp));
dmp->_vl_msg_id = ntohs(VL_API_DISCONNECT_SESSION);
dmp->client_index = g_svm.my_client_index;
dmp->handle = session->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&dmp);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_CLOSE);
}
static void
vl_api_reset_session_t_handler(vl_api_reset_session_t *mp)
{
vl_api_reset_session_reply_t *rmp;
int rv = 0;
struct spdk_vpp_session *session = 0;
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Reset session %p (%d) handler\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_DISCONNECT;
pthread_mutex_unlock(&g_svm.session_get_lock);
rmp = vl_msg_api_alloc(sizeof(*rmp));
if (rmp == NULL) {
return;
}
memset(rmp, 0, sizeof(*rmp));
rmp->_vl_msg_id = ntohs(VL_API_RESET_SESSION_REPLY);
rmp->retval = rv;
rmp->handle = mp->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&rmp);
}
/******************************************************************************
* Bind
*/
static void
vl_api_bind_sock_reply_t_handler(vl_api_bind_sock_reply_t *mp)
{
struct spdk_vpp_session *session;
/* Context should be set to the session index */
session = _spdk_vpp_session_get(mp->context);
if (mp->retval) {
SPDK_ERRLOG("Bind failed (%d).\n", ntohl(mp->retval));
session->app_session.session_state = VPP_SESSION_STATE_FAILED;
return;
}
/* Set local address */
session->app_session.transport.is_ip4 = mp->lcl_is_ip4;
memcpy(&session->app_session.transport.lcl_ip, mp->lcl_ip, sizeof(mp->lcl_ip));
session->app_session.transport.lcl_port = mp->lcl_port;
/* Register listener */
session->handle = mp->handle;
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Bind session %p (%d/%" PRIu64 ")\n",
session, session->id, session->handle);
/* Session binded, set listen state */
session->is_listen = true;
session->app_session.session_state = VPP_SESSION_STATE_READY;
}
static void
vl_api_unbind_sock_reply_t_handler(vl_api_unbind_sock_reply_t *mp)
{
struct spdk_vpp_session *session;
if (mp->retval != 0) {
SPDK_ERRLOG("Cannot unbind socket\n");
return;
}
session = _spdk_vpp_session_get(mp->context);
if (session == NULL) {
SPDK_ERRLOG("Cannot find a session by context\n");
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Unbind session %p (%d)\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_CLOSE;
}
static int
_spdk_send_unbind_sock(struct spdk_vpp_session *session)
{
vl_api_unbind_sock_t *ump;
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Unbind session %p (%d) request\n", session, session->id);
ump = vl_msg_api_alloc(sizeof(*ump));
if (ump == NULL) {
return -ENOMEM;
}
memset(ump, 0, sizeof(*ump));
ump->_vl_msg_id = ntohs(VL_API_UNBIND_SOCK);
ump->client_index = g_svm.my_client_index;
ump->handle = session->handle;
ump->context = session->id;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&ump);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_CLOSE);
}
/******************************************************************************
* Accept session
* VPP message handlers
*/
static void
vl_api_accept_session_t_handler(vl_api_accept_session_t *mp)
@ -641,6 +342,299 @@ vl_api_accept_session_t_handler(vl_api_accept_session_t *mp)
pthread_mutex_unlock(&listen_session->accept_session_lock);
}
static void
vl_api_connect_session_reply_t_handler(vl_api_connect_session_reply_t *mp)
{
struct spdk_vpp_session *session;
svm_fifo_t *rx_fifo, *tx_fifo;
session = _spdk_vpp_session_get(mp->context);
if (session == NULL) {
return;
}
if (mp->retval) {
SPDK_ERRLOG("Connection failed (%d).\n", ntohl(mp->retval));
session->app_session.session_state = VPP_SESSION_STATE_FAILED;
return;
}
session->app_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 *);
rx_fifo->client_session_index = session->id;
tx_fifo = uword_to_pointer(mp->server_tx_fifo, svm_fifo_t *);
tx_fifo->client_session_index = session->id;
session->app_session.rx_fifo = rx_fifo;
session->app_session.tx_fifo = tx_fifo;
session->handle = mp->handle;
/* Set lcl addr */
session->app_session.transport.is_ip4 = mp->is_ip4;
memcpy(&session->app_session.transport.lcl_ip, mp->lcl_ip, sizeof(mp->lcl_ip));
session->app_session.transport.lcl_port = mp->lcl_port;
session->app_session.session_state = VPP_SESSION_STATE_READY;
}
static void
vl_api_disconnect_session_t_handler(vl_api_disconnect_session_t *mp)
{
struct spdk_vpp_session *session = 0;
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Disconnect session %p (%d) handler\n", session, session->id);
/* We need to postpone session deletion to inform upper layer */
session->app_session.session_state = VPP_SESSION_STATE_DISCONNECT;
pthread_mutex_unlock(&g_svm.session_get_lock);
}
static void
vl_api_reset_session_t_handler(vl_api_reset_session_t *mp)
{
vl_api_reset_session_reply_t *rmp;
int rv = 0;
struct spdk_vpp_session *session = 0;
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Reset session %p (%d) handler\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_DISCONNECT;
pthread_mutex_unlock(&g_svm.session_get_lock);
rmp = vl_msg_api_alloc(sizeof(*rmp));
if (rmp == NULL) {
return;
}
memset(rmp, 0, sizeof(*rmp));
rmp->_vl_msg_id = ntohs(VL_API_RESET_SESSION_REPLY);
rmp->retval = rv;
rmp->handle = mp->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&rmp);
}
static void
vl_api_bind_sock_reply_t_handler(vl_api_bind_sock_reply_t *mp)
{
struct spdk_vpp_session *session;
/* Context should be set to the session index */
session = _spdk_vpp_session_get(mp->context);
if (mp->retval) {
SPDK_ERRLOG("Bind failed (%d).\n", ntohl(mp->retval));
session->app_session.session_state = VPP_SESSION_STATE_FAILED;
return;
}
/* Set local address */
session->app_session.transport.is_ip4 = mp->lcl_is_ip4;
memcpy(&session->app_session.transport.lcl_ip, mp->lcl_ip, sizeof(mp->lcl_ip));
session->app_session.transport.lcl_port = mp->lcl_port;
/* Register listener */
session->handle = mp->handle;
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Bind session %p (%d/%" PRIu64 ")\n",
session, session->id, session->handle);
/* Session binded, set listen state */
session->is_listen = true;
session->app_session.session_state = VPP_SESSION_STATE_READY;
}
static void
vl_api_unbind_sock_reply_t_handler(vl_api_unbind_sock_reply_t *mp)
{
struct spdk_vpp_session *session;
if (mp->retval != 0) {
SPDK_ERRLOG("Cannot unbind socket\n");
return;
}
session = _spdk_vpp_session_get(mp->context);
if (session == NULL) {
SPDK_ERRLOG("Cannot find a session by context\n");
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Unbind session %p (%d)\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_CLOSE;
}
static int
vpp_queue_poller(void *ctx)
{
uword msg;
if (g_svm.vl_output_queue->cursize > 0 &&
!svm_queue_sub_raw(g_svm.vl_output_queue, (u8 *)&msg)) {
vl_msg_api_handler((void *)msg);
}
return 0;
}
static int
app_queue_poller(void *ctx)
{
svm_msg_q_msg_t msg;
if (!svm_msg_q_is_empty(g_svm.app_event_queue)) {
svm_msg_q_sub(g_svm.app_event_queue, &msg, SVM_Q_WAIT, 0);
svm_msg_q_free_msg(g_svm.app_event_queue, &msg);
}
return 0;
}
/* This is required until sock.c API changes to asynchronous */
static int
_wait_for_session_state_change(struct spdk_vpp_session *session, enum spdk_vpp_session_state state)
{
time_t start = time(NULL);
while (time(NULL) - start < 10) {
if (session->app_session.session_state == VPP_SESSION_STATE_FAILED) {
errno = EADDRNOTAVAIL;
return -1;
}
if (session->app_session.session_state == state) {
errno = 0;
return 0;
}
if (spdk_get_thread() == g_svm.init_thread) {
usleep(100000);
app_queue_poller(NULL);
vpp_queue_poller(NULL);
}
}
/* timeout */
errno = ETIMEDOUT;
return -1;
}
static int
_spdk_vpp_session_connect(struct spdk_vpp_session *session)
{
vl_api_connect_sock_t *cmp;
cmp = vl_msg_api_alloc(sizeof(*cmp));
if (cmp == NULL) {
return -ENOMEM;
}
memset(cmp, 0, sizeof(*cmp));
cmp->_vl_msg_id = ntohs(VL_API_CONNECT_SOCK);
cmp->client_index = g_svm.my_client_index;
cmp->context = session->id;
cmp->vrf = 0 /* VPPCOM_VRF_DEFAULT */;
cmp->is_ip4 = (session->app_session.transport.is_ip4);
memcpy(cmp->ip, &session->app_session.transport.rmt_ip, sizeof(cmp->ip));
cmp->port = session->app_session.transport.rmt_port;
cmp->proto = TRANSPORT_PROTO_TCP;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&cmp);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_READY);
}
static void
vl_api_disconnect_session_reply_t_handler(vl_api_disconnect_session_reply_t *mp)
{
struct spdk_vpp_session *session;
if (mp->retval) {
SPDK_ERRLOG("Disconnecting session failed (%d).\n", ntohl(mp->retval));
return;
}
pthread_mutex_lock(&g_svm.session_get_lock);
session = _spdk_vpp_session_get_by_handle(mp->handle, false);
if (session == NULL) {
SPDK_ERRLOG("Invalid session handler (%" PRIu64 ").\n", mp->handle);
pthread_mutex_unlock(&g_svm.session_get_lock);
return;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Session disconnected %p (%d)\n", session, session->id);
session->app_session.session_state = VPP_SESSION_STATE_CLOSE;
pthread_mutex_unlock(&g_svm.session_get_lock);
}
static int
_spdk_vpp_session_disconnect(struct spdk_vpp_session *session)
{
int rv = 0;
vl_api_disconnect_session_t *dmp;
vl_api_disconnect_session_reply_t *rmp;
if (session->app_session.session_state == VPP_SESSION_STATE_DISCONNECT) {
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Session is already in disconnecting state %p (%d)\n",
session, session->id);
rmp = vl_msg_api_alloc(sizeof(*rmp));
if (rmp == NULL) {
return -ENOMEM;
}
memset(rmp, 0, sizeof(*rmp));
rmp->_vl_msg_id = ntohs(VL_API_DISCONNECT_SESSION_REPLY);
rmp->retval = rv;
rmp->handle = session->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&rmp);
return 0;
}
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Disconnect session %p (%d)\n", session, session->id);
dmp = vl_msg_api_alloc(sizeof(*dmp));
if (dmp == NULL) {
return -ENOMEM;
}
memset(dmp, 0, sizeof(*dmp));
dmp->_vl_msg_id = ntohs(VL_API_DISCONNECT_SESSION);
dmp->client_index = g_svm.my_client_index;
dmp->handle = session->handle;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&dmp);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_CLOSE);
}
static int
_spdk_send_unbind_sock(struct spdk_vpp_session *session)
{
vl_api_unbind_sock_t *ump;
SPDK_DEBUGLOG(SPDK_SOCK_VPP, "Unbind session %p (%d) request\n", session, session->id);
ump = vl_msg_api_alloc(sizeof(*ump));
if (ump == NULL) {
return -ENOMEM;
}
memset(ump, 0, sizeof(*ump));
ump->_vl_msg_id = ntohs(VL_API_UNBIND_SOCK);
ump->client_index = g_svm.my_client_index;
ump->handle = session->handle;
ump->context = session->id;
vl_msg_api_send_shmem(g_svm.vl_input_queue, (u8 *)&ump);
return _wait_for_session_state_change(session, VPP_SESSION_STATE_CLOSE);
}
static int
_spdk_vpp_session_listen(struct spdk_vpp_session *session)
{