tls: fix disconnects for sessions with pending data

[vpp.git] / src / vnet / session-apps / echo_client.c

diff --git a/src/vnet/session-apps/echo_client.c b/src/vnet/session-apps/echo_client.c
index d47b0d9..b47dcf2 100644 (file)
--- a/src/vnet/session-apps/echo_client.c
+++ b/src/vnet/session-apps/echo_client.c
@@ -43,7 +43,7 @@ signal_evt_to_cli (int code)
 }
 
 static void
-send_data_chunk (echo_client_main_t * ecm, session_t * s)
+send_data_chunk (echo_client_main_t * ecm, eclient_session_t * s)
 {
   u8 *test_data = ecm->connect_test_data;
   int test_buf_len, test_buf_offset, rv;
@@ -56,11 +56,50 @@ send_data_chunk (echo_client_main_t * ecm, session_t * s)
                               s->bytes_to_send);
 
   if (!ecm->is_dgram)
-    rv = app_send_stream (&s->data, test_data + test_buf_offset,
-                         bytes_this_chunk, 0);
+    {
+      if (ecm->no_copy)
+       {
+         svm_fifo_t *f = s->data.tx_fifo;
+         rv = clib_min (svm_fifo_max_enqueue (f), bytes_this_chunk);
+         svm_fifo_enqueue_nocopy (f, rv);
+         session_send_io_evt_to_thread_custom (f, s->thread_index,
+                                               FIFO_EVENT_APP_TX);
+       }
+      else
+       rv = app_send_stream (&s->data, test_data + test_buf_offset,
+                             bytes_this_chunk, 0);
+    }
   else
-    rv = app_send_dgram (&s->data, test_data + test_buf_offset,
-                        bytes_this_chunk, 0);
+    {
+      if (ecm->no_copy)
+       {
+         session_dgram_hdr_t hdr;
+         svm_fifo_t *f = s->data.tx_fifo;
+         app_session_transport_t *at = &s->data.transport;
+         u32 max_enqueue = svm_fifo_max_enqueue (f);
+
+         if (max_enqueue <= sizeof (session_dgram_hdr_t))
+           return;
+
+         max_enqueue -= sizeof (session_dgram_hdr_t);
+         rv = clib_min (max_enqueue, bytes_this_chunk);
+
+         hdr.data_length = rv;
+         hdr.data_offset = 0;
+         clib_memcpy (&hdr.rmt_ip, &at->rmt_ip, sizeof (ip46_address_t));
+         hdr.is_ip4 = at->is_ip4;
+         hdr.rmt_port = at->rmt_port;
+         clib_memcpy (&hdr.lcl_ip, &at->lcl_ip, sizeof (ip46_address_t));
+         hdr.lcl_port = at->lcl_port;
+         svm_fifo_enqueue_nowait (f, sizeof (hdr), (u8 *) & hdr);
+         svm_fifo_enqueue_nocopy (f, rv);
+         session_send_io_evt_to_thread_custom (f, s->thread_index,
+                                               FIFO_EVENT_APP_TX);
+       }
+      else
+       rv = app_send_dgram (&s->data, test_data + test_buf_offset,
+                            bytes_this_chunk, 0);
+    }
 
   /* If we managed to enqueue data... */
   if (rv > 0)
@@ -91,7 +130,7 @@ send_data_chunk (echo_client_main_t * ecm, session_t * s)
 }
 
 static void
-receive_data_chunk (echo_client_main_t * ecm, session_t * s)
+receive_data_chunk (echo_client_main_t * ecm, eclient_session_t * s)
 {
   svm_fifo_t *rx_fifo = s->data.rx_fifo;
   u32 thread_index = vlib_get_thread_index ();
@@ -158,7 +197,7 @@ echo_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
 {
   echo_client_main_t *ecm = &echo_client_main;
   int my_thread_index = vlib_get_thread_index ();
-  session_t *sp;
+  eclient_session_t *sp;
   int i;
   int delete_session;
   u32 *connection_indices;
@@ -318,9 +357,9 @@ echo_clients_session_connected_callback (u32 app_index, u32 api_context,
                                         stream_session_t * s, u8 is_fail)
 {
   echo_client_main_t *ecm = &echo_client_main;
-  session_t *session;
+  eclient_session_t *session;
   u32 session_index;
-  u8 thread_index = vlib_get_thread_index ();
+  u8 thread_index;
 
   if (is_fail)
     {
@@ -329,7 +368,9 @@ echo_clients_session_connected_callback (u32 app_index, u32 api_context,
       return 0;
     }
 
-  ASSERT (s->thread_index == thread_index);
+  thread_index = s->thread_index;
+  ASSERT (thread_index == vlib_get_thread_index ()
+         || session_transport_service_type (s) == TRANSPORT_SERVICE_CL);
 
   if (!ecm->vpp_event_queue[thread_index])
     ecm->vpp_event_queue[thread_index] =
@@ -404,7 +445,7 @@ static int
 echo_clients_rx_callback (stream_session_t * s)
 {
   echo_client_main_t *ecm = &echo_client_main;
-  session_t *sp;
+  eclient_session_t *sp;
 
   sp = pool_elt_at_index (ecm->sessions,
                          s->server_rx_fifo->client_session_index);
@@ -412,18 +453,9 @@ echo_clients_rx_callback (stream_session_t * s)
 
   if (svm_fifo_max_dequeue (s->server_rx_fifo))
     {
-      session_fifo_event_t evt;
-      svm_queue_t *q;
       if (svm_fifo_set_event (s->server_rx_fifo))
-       {
-         evt.fifo = s->server_rx_fifo;
-         evt.event_type = FIFO_EVENT_BUILTIN_RX;
-         q = session_manager_get_vpp_event_queue (s->thread_index);
-         if (PREDICT_FALSE (q->cursize == q->maxsize))
-           clib_warning ("out of event queue space");
-         else if (svm_queue_add (q, (u8 *) & evt, 0))
-           clib_warning ("failed to enqueue self-tap");
-       }
+       session_send_io_evt_to_thread (s->server_rx_fifo,
+                                      FIFO_EVENT_BUILTIN_RX);
     }
   return 0;
 }
@@ -591,6 +623,7 @@ echo_clients_command_fn (vlib_main_t * vm,
   ecm->test_failed = 0;
   ecm->vlib_main = vm;
   ecm->tls_engine = TLS_ENGINE_OPENSSL;
+  ecm->no_copy = 0;
 
   if (thread_main->n_vlib_mains > 1)
     clib_spinlock_init (&ecm->sessions_lock);
@@ -707,13 +740,7 @@ echo_clients_command_fn (vlib_main_t * vm,
                         VLIB_NODE_STATE_POLLING);
 
   if (preallocate_sessions)
-    {
-      session_t *sp __attribute__ ((unused));
-      for (i = 0; i < n_clients; i++)
-       pool_get (ecm->sessions, sp);
-      for (i = 0; i < n_clients; i++)
-       pool_put_index (ecm->sessions, i);
-    }
+    pool_init_fixed (ecm->sessions, 1.1 * n_clients);
 
   /* Fire off connect requests */
   time_before_connects = vlib_time_now (vm);
@@ -799,6 +826,7 @@ echo_clients_command_fn (vlib_main_t * vm,
 
 cleanup:
   ecm->run_test = 0;
+  vlib_process_wait_for_event_or_clock (vm, 10e-3);
   for (i = 0; i < vec_len (ecm->connection_index_by_thread); i++)
     {
       vec_reset_length (ecm->connection_index_by_thread[i]);