session: segment handle in accept/connect notifications

[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 3d1af67..51a85c0 100644 (file)
--- a/src/vnet/session-apps/echo_client.c
+++ b/src/vnet/session-apps/echo_client.c
@@ -86,10 +86,12 @@ send_data_chunk (echo_client_main_t * ecm, eclient_session_t * s)
 
          hdr.data_length = rv;
          hdr.data_offset = 0;
-         clib_memcpy (&hdr.rmt_ip, &at->rmt_ip, sizeof (ip46_address_t));
+         clib_memcpy_fast (&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));
+         clib_memcpy_fast (&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);
@@ -208,7 +210,7 @@ echo_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
   connections_this_batch =
     ecm->connections_this_batch_by_thread[my_thread_index];
 
-  if ((ecm->run_test == 0) ||
+  if ((ecm->run_test != ECHO_CLIENTS_RUNNING) ||
       ((vec_len (connection_indices) == 0)
        && vec_len (connections_this_batch) == 0))
     return 0;
@@ -221,10 +223,10 @@ echo_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
 
       ASSERT (nconnections_this_batch > 0);
       vec_validate (connections_this_batch, nconnections_this_batch - 1);
-      clib_memcpy (connections_this_batch,
-                  connection_indices + vec_len (connection_indices)
-                  - nconnections_this_batch,
-                  nconnections_this_batch * sizeof (u32));
+      clib_memcpy_fast (connections_this_batch,
+                       connection_indices + vec_len (connection_indices)
+                       - nconnections_this_batch,
+                       nconnections_this_batch * sizeof (u32));
       _vec_len (connection_indices) -= nconnections_this_batch;
     }
 
@@ -263,8 +265,8 @@ echo_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
        {
          stream_session_t *s;
 
-         __sync_fetch_and_add (&ecm->tx_total, sp->bytes_sent);
-         __sync_fetch_and_add (&ecm->rx_total, sp->bytes_received);
+         clib_atomic_fetch_add (&ecm->tx_total, sp->bytes_sent);
+         clib_atomic_fetch_add (&ecm->rx_total, sp->bytes_received);
          s = session_get_from_handle_if_valid (sp->vpp_session_handle);
 
          if (s)
@@ -276,7 +278,7 @@ echo_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
 
              vec_delete (connections_this_batch, 1, i);
              i--;
-             __sync_fetch_and_add (&ecm->ready_connections, -1);
+             clib_atomic_fetch_add (&ecm->ready_connections, -1);
            }
          else
            {
@@ -359,15 +361,20 @@ echo_clients_session_connected_callback (u32 app_index, u32 api_context,
   echo_client_main_t *ecm = &echo_client_main;
   eclient_session_t *session;
   u32 session_index;
-  u8 thread_index = s->thread_index;
+  u8 thread_index;
+
+  if (PREDICT_FALSE (ecm->run_test != ECHO_CLIENTS_STARTING))
+    return -1;
 
   if (is_fail)
     {
       clib_warning ("connection %d failed!", api_context);
+      ecm->run_test = ECHO_CLIENTS_EXITING;
       signal_evt_to_cli (-1);
       return 0;
     }
 
+  thread_index = s->thread_index;
   ASSERT (thread_index == vlib_get_thread_index ()
          || session_transport_service_type (s) == TRANSPORT_SERVICE_CL);
 
@@ -382,7 +389,7 @@ echo_clients_session_connected_callback (u32 app_index, u32 api_context,
   pool_get (ecm->sessions, session);
   clib_spinlock_unlock_if_init (&ecm->sessions_lock);
 
-  memset (session, 0, sizeof (*session));
+  clib_memset (session, 0, sizeof (*session));
   session_index = session - ecm->sessions;
   session->bytes_to_send = ecm->bytes_to_send;
   session->bytes_to_receive = ecm->no_return ? 0ULL : ecm->bytes_to_send;
@@ -397,16 +404,16 @@ echo_clients_session_connected_callback (u32 app_index, u32 api_context,
     {
       transport_connection_t *tc;
       tc = session_get_transport (s);
-      clib_memcpy (&session->data.transport, tc,
-                  sizeof (session->data.transport));
+      clib_memcpy_fast (&session->data.transport, tc,
+                       sizeof (session->data.transport));
       session->data.is_dgram = 1;
     }
 
   vec_add1 (ecm->connection_index_by_thread[thread_index], session_index);
-  __sync_fetch_and_add (&ecm->ready_connections, 1);
+  clib_atomic_fetch_add (&ecm->ready_connections, 1);
   if (ecm->ready_connections == ecm->expected_connections)
     {
-      ecm->run_test = 1;
+      ecm->run_test = ECHO_CLIENTS_RUNNING;
       /* Signal the CLI process that the action is starting... */
       signal_evt_to_cli (1);
     }
@@ -440,12 +447,28 @@ echo_clients_session_disconnect_callback (stream_session_t * s)
   return;
 }
 
+void
+echo_clients_session_disconnect (stream_session_t * s)
+{
+  echo_client_main_t *ecm = &echo_client_main;
+  vnet_disconnect_args_t _a, *a = &_a;
+  a->handle = session_handle (s);
+  a->app_index = ecm->app_index;
+  vnet_disconnect_session (a);
+}
+
 static int
 echo_clients_rx_callback (stream_session_t * s)
 {
   echo_client_main_t *ecm = &echo_client_main;
   eclient_session_t *sp;
 
+  if (PREDICT_FALSE (ecm->run_test != ECHO_CLIENTS_RUNNING))
+    {
+      echo_clients_session_disconnect (s);
+      return -1;
+    }
+
   sp = pool_elt_at_index (ecm->sessions,
                          s->server_rx_fifo->client_session_index);
   receive_data_chunk (ecm, sp);
@@ -460,7 +483,7 @@ echo_clients_rx_callback (stream_session_t * s)
 }
 
 int
-echo_client_add_segment_callback (u32 client_index, const ssvm_private_t * sp)
+echo_client_add_segment_callback (u32 client_index, u64 segment_handle)
 {
   /* New heaps may be added */
   return 0;
@@ -486,8 +509,8 @@ echo_clients_attach (u8 * appns_id, u64 appns_flags, u64 appns_secret)
   u64 options[16];
   clib_error_t *error = 0;
 
-  memset (a, 0, sizeof (*a));
-  memset (options, 0, sizeof (options));
+  clib_memset (a, 0, sizeof (*a));
+  clib_memset (options, 0, sizeof (options));
 
   a->api_client_index = ecm->my_client_index;
   a->session_cb_vft = &echo_clients;
@@ -567,7 +590,7 @@ echo_clients_connect (vlib_main_t * vm, u32 n_clients)
   clib_error_t *error = 0;
   int i;
 
-  memset (a, 0, sizeof (*a));
+  clib_memset (a, 0, sizeof (*a));
   for (i = 0; i < n_clients; i++)
     {
       a->uri = (char *) ecm->connect_uri;
@@ -623,6 +646,7 @@ echo_clients_command_fn (vlib_main_t * vm,
   ecm->vlib_main = vm;
   ecm->tls_engine = TLS_ENGINE_OPENSSL;
   ecm->no_copy = 0;
+  ecm->run_test = ECHO_CLIENTS_STARTING;
 
   if (thread_main->n_vlib_mains > 1)
     clib_spinlock_init (&ecm->sessions_lock);
@@ -744,7 +768,7 @@ echo_clients_command_fn (vlib_main_t * vm,
   /* Fire off connect requests */
   time_before_connects = vlib_time_now (vm);
   if ((error = echo_clients_connect (vm, n_clients)))
-    return error;
+    goto cleanup;
 
   /* Park until the sessions come up, or ten seconds elapse... */
   vlib_process_wait_for_event_or_clock (vm, syn_timeout);
@@ -824,7 +848,8 @@ echo_clients_command_fn (vlib_main_t * vm,
     error = clib_error_return (0, "failed: test bytes");
 
 cleanup:
-  ecm->run_test = 0;
+  ecm->run_test = ECHO_CLIENTS_EXITING;
+  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]);