#include <stdio.h>
#include <signal.h>
-#include <vlib/vlib.h>
-#include <vnet/vnet.h>
#include <svm/svm_fifo_segment.h>
#include <vlibmemory/api.h>
#include <vpp/api/vpe_msg_enum.h>
svm_fifo_t *server_rx_fifo;
svm_fifo_t *server_tx_fifo;
- u32 vpp_session_index;
- u32 vpp_session_thread;
+ u64 vpp_session_handle;
} session_t;
typedef enum
{
STATE_START,
+ STATE_ATTACHED,
STATE_READY,
STATE_DISCONNECTING,
STATE_FAILED
pthread_t client_rx_thread_handle;
u32 client_bytes_received;
u8 test_return_packets;
+ u64 bytes_to_send;
/* convenience */
svm_fifo_segment_main_t *segment_main;
#define NITER 4000000
#endif
+static u8 *
+format_api_error (u8 * s, va_list * args)
+{
+ uri_tcp_test_main_t *utm = &uri_tcp_test_main;
+ i32 error = va_arg (*args, u32);
+ uword *p;
+
+ p = hash_get (utm->error_string_by_error_number, -error);
+
+ if (p)
+ s = format (s, "%s", p[0]);
+ else
+ s = format (s, "%d", error);
+ return s;
+}
+
+static void
+init_error_string_table (uri_tcp_test_main_t * utm)
+{
+ utm->error_string_by_error_number = hash_create (0, sizeof (uword));
+
+#define _(n,v,s) hash_set (utm->error_string_by_error_number, -v, s);
+ foreach_vnet_api_error;
+#undef _
+
+ hash_set (utm->error_string_by_error_number, 99, "Misc");
+}
+
int
wait_for_state_change (uri_tcp_test_main_t * utm, connection_state_t state)
{
return -1;
}
+void
+application_send_attach (uri_tcp_test_main_t * utm)
+{
+ vl_api_application_attach_t *bmp;
+ u32 fifo_size = 3 << 20;
+ bmp = vl_msg_api_alloc (sizeof (*bmp));
+ memset (bmp, 0, sizeof (*bmp));
+
+ bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
+ bmp->client_index = utm->my_client_index;
+ bmp->context = ntohl (0xfeedface);
+ bmp->options[APP_OPTIONS_FLAGS] =
+ APP_OPTIONS_FLAGS_USE_FIFO | APP_OPTIONS_FLAGS_ADD_SEGMENT;
+ bmp->options[SESSION_OPTIONS_RX_FIFO_SIZE] = fifo_size;
+ bmp->options[SESSION_OPTIONS_TX_FIFO_SIZE] = fifo_size;
+ bmp->options[SESSION_OPTIONS_ADD_SEGMENT_SIZE] = 128 << 20;
+ bmp->options[SESSION_OPTIONS_SEGMENT_SIZE] = 256 << 20;
+ vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & bmp);
+}
+
+int
+application_attach (uri_tcp_test_main_t * utm)
+{
+ application_send_attach (utm);
+ if (wait_for_state_change (utm, STATE_ATTACHED))
+ {
+ clib_warning ("timeout waiting for STATE_ATTACHED");
+ return -1;
+ }
+ return 0;
+}
+
+void
+application_detach (uri_tcp_test_main_t * utm)
+{
+ vl_api_application_detach_t *bmp;
+ bmp = vl_msg_api_alloc (sizeof (*bmp));
+ memset (bmp, 0, sizeof (*bmp));
+
+ bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
+ bmp->client_index = utm->my_client_index;
+ bmp->context = ntohl (0xfeedface);
+ vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & bmp);
+}
+
static void
-init_error_string_table (uri_tcp_test_main_t * utm)
+vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
+ mp)
{
- utm->error_string_by_error_number = hash_create (0, sizeof (uword));
+ uri_tcp_test_main_t *utm = &uri_tcp_test_main;
+ svm_fifo_segment_create_args_t _a, *a = &_a;
+ int rv;
-#define _(n,v,s) hash_set (utm->error_string_by_error_number, -v, s);
- foreach_vnet_api_error;
-#undef _
+ if (mp->retval)
+ {
+ clib_warning ("attach failed: %U", format_api_error,
+ clib_net_to_host_u32 (mp->retval));
+ utm->state = STATE_FAILED;
+ return;
+ }
- hash_set (utm->error_string_by_error_number, 99, "Misc");
+ if (mp->segment_name_length == 0)
+ {
+ clib_warning ("segment_name_length zero");
+ return;
+ }
+
+ a->segment_name = (char *) mp->segment_name;
+ a->segment_size = mp->segment_size;
+
+ ASSERT (mp->app_event_queue_address);
+
+ /* Attach to the segment vpp created */
+ rv = svm_fifo_segment_attach (a);
+ if (rv)
+ {
+ clib_warning ("svm_fifo_segment_attach ('%s') failed",
+ mp->segment_name);
+ return;
+ }
+
+ utm->our_event_queue =
+ (unix_shared_memory_queue_t *) mp->app_event_queue_address;
+ utm->state = STATE_ATTACHED;
+}
+
+static void
+vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
+ mp)
+{
+ if (mp->retval)
+ clib_warning ("detach returned with err: %d", mp->retval);
}
static void
vl_api_disconnect_session_reply_t *rmp;
uword *p;
int rv = 0;
- u64 key;
- key = (((u64) mp->session_thread_index) << 32) | (u64) mp->session_index;
-
- p = hash_get (utm->session_index_by_vpp_handles, key);
+ p = hash_get (utm->session_index_by_vpp_handles, mp->handle);
if (p)
{
session = pool_elt_at_index (utm->sessions, p[0]);
- hash_unset (utm->session_index_by_vpp_handles, key);
+ hash_unset (utm->session_index_by_vpp_handles, mp->handle);
pool_put (utm->sessions, session);
}
else
{
- clib_warning ("couldn't find session key %llx", key);
+ clib_warning ("couldn't find session key %llx", mp->handle);
rv = -11;
}
rmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION_REPLY);
rmp->retval = rv;
- rmp->session_index = mp->session_index;
- rmp->session_thread_index = mp->session_thread_index;
+ rmp->handle = mp->handle;
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & rmp);
}
vl_api_reset_session_reply_t *rmp;
uword *p;
int rv = 0;
- u64 key;
-
- key = (((u64) mp->session_thread_index) << 32) | (u64) mp->session_index;
- p = hash_get (utm->session_index_by_vpp_handles, key);
+ p = hash_get (utm->session_index_by_vpp_handles, mp->handle);
if (p)
{
session = pool_elt_at_index (utm->sessions, p[0]);
- hash_unset (utm->session_index_by_vpp_handles, key);
+ hash_unset (utm->session_index_by_vpp_handles, mp->handle);
pool_put (utm->sessions, session);
utm->time_to_stop = 1;
}
else
{
- clib_warning ("couldn't find session key %llx", key);
+ clib_warning ("couldn't find session key %llx", mp->handle);
rv = -11;
}
memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_RESET_SESSION_REPLY);
rmp->retval = rv;
- rmp->session_index = mp->session_index;
- rmp->session_thread_index = mp->session_thread_index;
+ rmp->handle = mp->handle;
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & rmp);
}
rx_fifo = e->fifo;
- bytes = e->enqueue_length;
+ bytes = svm_fifo_max_dequeue (rx_fifo);
+ /* Allow enqueuing of new event */
+ svm_fifo_unset_event (rx_fifo);
+
+ /* Read the bytes */
do
{
- n_read = svm_fifo_dequeue_nowait (rx_fifo, 0, vec_len (utm->rx_buf),
- utm->rx_buf);
+ n_read = svm_fifo_dequeue_nowait (rx_fifo,
+ clib_min (vec_len (utm->rx_buf),
+ bytes), utm->rx_buf);
if (n_read > 0)
{
bytes -= n_read;
}
utm->client_bytes_received += n_read;
}
+ else
+ {
+ if (n_read == -2)
+ {
+// clib_warning ("weird!");
+ break;
+ }
+ }
}
- while (n_read < 0 || bytes > 0);
+ while (bytes > 0);
}
void
0 /* nowait */ );
switch (e->event_type)
{
- case FIFO_EVENT_SERVER_RX:
+ case FIFO_EVENT_APP_RX:
client_handle_fifo_event_rx (utm, e);
break;
- case FIFO_EVENT_SERVER_EXIT:
+ case FIFO_EVENT_DISCONNECT:
return;
default:
0 /* nowait */ );
switch (e->event_type)
{
- case FIFO_EVENT_SERVER_RX:
+ case FIFO_EVENT_APP_RX:
client_handle_fifo_event_rx (utm, e);
break;
- case FIFO_EVENT_SERVER_EXIT:
+ case FIFO_EVENT_DISCONNECT:
return 0;
default:
clib_warning ("unknown event type %d", e->event_type);
vl_api_connect_uri_reply_t_handler (vl_api_connect_uri_reply_t * mp)
{
uri_tcp_test_main_t *utm = &uri_tcp_test_main;
- svm_fifo_segment_create_args_t _a, *a = &_a;
session_t *session;
u32 session_index;
svm_fifo_t *rx_fifo, *tx_fifo;
int rv;
- u64 key;
if (mp->retval)
{
- clib_warning ("connection failed with code: %d", mp->retval);
- utm->state = STATE_FAILED;
- return;
- }
-
- /*
- * Attatch to segment
- */
-
- if (mp->segment_name_length == 0)
- {
- clib_warning ("segment_name_length zero");
+ clib_warning ("connection failed with code: %U", format_api_error,
+ clib_net_to_host_u32 (mp->retval));
utm->state = STATE_FAILED;
return;
}
- a->segment_name = (char *) mp->segment_name;
- a->segment_size = mp->segment_size;
-
- ASSERT (mp->client_event_queue_address);
-
- /* Attach to the segment vpp created */
- rv = svm_fifo_segment_attach (a);
- if (rv)
- {
- clib_warning ("svm_fifo_segment_attach ('%s') failed",
- mp->segment_name);
- return;
- }
-
- /*
- * Save the queues
- */
-
- utm->our_event_queue = (unix_shared_memory_queue_t *)
- mp->client_event_queue_address;
-
utm->vpp_event_queue = (unix_shared_memory_queue_t *)
mp->vpp_event_queue_address;
session->server_rx_fifo = rx_fifo;
session->server_tx_fifo = tx_fifo;
- session->vpp_session_index = mp->session_index;
- session->vpp_session_thread = mp->session_thread_index;
+ session->vpp_session_handle = mp->handle;
/* Save handle */
utm->connected_session_index = session_index;
utm->state = STATE_READY;
/* Add it to lookup table */
- key = (((u64) mp->session_thread_index) << 32) | (u64) mp->session_index;
- hash_set (utm->session_index_by_vpp_handles, key, session_index);
+ hash_set (utm->session_index_by_vpp_handles, mp->handle, session_index);
/* Start RX thread */
rv = pthread_create (&utm->client_rx_thread_handle,
}
}
-void
-client_send_data (uri_tcp_test_main_t * utm)
+static void
+send_test_chunk (uri_tcp_test_main_t * utm, svm_fifo_t * tx_fifo, int mypid,
+ u32 bytes)
{
u8 *test_data = utm->connect_test_data;
u64 bytes_sent = 0;
- int rv;
- int mypid = getpid ();
- session_t *session;
- svm_fifo_t *tx_fifo;
- int buffer_offset, bytes_to_send = 0;
+ int test_buf_offset = 0;
+ u32 bytes_to_snd;
+ u32 queue_max_chunk = 64 << 10, actual_write;
session_fifo_event_t evt;
static int serial_number = 0;
- int i;
- u32 max_chunk = 64 << 10, write;
+ int rv;
- session = pool_elt_at_index (utm->sessions, utm->connected_session_index);
- tx_fifo = session->server_tx_fifo;
+ bytes_to_snd = (bytes == 0) ? vec_len (test_data) : bytes;
+ if (bytes_to_snd > vec_len (test_data))
+ bytes_to_snd = vec_len (test_data);
- vec_validate (utm->rx_buf, vec_len (test_data) - 1);
-
- for (i = 0; i < 1; i++)
+ while (bytes_to_snd > 0)
{
- bytes_to_send = vec_len (test_data);
- buffer_offset = 0;
- while (bytes_to_send > 0)
+ actual_write =
+ bytes_to_snd > queue_max_chunk ? queue_max_chunk : bytes_to_snd;
+ rv = svm_fifo_enqueue_nowait (tx_fifo, actual_write,
+ test_data + test_buf_offset);
+
+ if (rv > 0)
{
- write = bytes_to_send > max_chunk ? max_chunk : bytes_to_send;
- rv = svm_fifo_enqueue_nowait (tx_fifo, mypid, write,
- test_data + buffer_offset);
+ bytes_to_snd -= rv;
+ test_buf_offset += rv;
+ bytes_sent += rv;
- if (rv > 0)
+ if (svm_fifo_set_event (tx_fifo))
{
- bytes_to_send -= rv;
- buffer_offset += rv;
- bytes_sent += rv;
-
/* Fabricate TX event, send to vpp */
evt.fifo = tx_fifo;
- evt.event_type = FIFO_EVENT_SERVER_TX;
- /* $$$$ for event logging */
- evt.enqueue_length = rv;
+ evt.event_type = FIFO_EVENT_APP_TX;
evt.event_id = serial_number++;
unix_shared_memory_queue_add (utm->vpp_event_queue,
}
}
}
+}
+
+void
+client_send_data (uri_tcp_test_main_t * utm)
+{
+ u8 *test_data = utm->connect_test_data;
+ int mypid = getpid ();
+ session_t *session;
+ svm_fifo_t *tx_fifo;
+ u32 n_iterations, leftover;
+ int i;
+
+ session = pool_elt_at_index (utm->sessions, utm->connected_session_index);
+ tx_fifo = session->server_tx_fifo;
+
+ vec_validate (utm->rx_buf, vec_len (test_data) - 1);
+ n_iterations = utm->bytes_to_send / vec_len (test_data);
+
+ for (i = 0; i < n_iterations; i++)
+ {
+ send_test_chunk (utm, tx_fifo, mypid, 0);
+ }
+
+ leftover = utm->bytes_to_send % vec_len (test_data);
+ if (leftover)
+ send_test_chunk (utm, tx_fifo, mypid, leftover);
if (utm->test_return_packets)
{
f64 timeout = clib_time_now (&utm->clib_time) + 2;
/* Wait for the outstanding packets */
- while (utm->client_bytes_received < vec_len (test_data))
+ while (utm->client_bytes_received <
+ vec_len (test_data) * n_iterations + leftover)
{
if (clib_time_now (&utm->clib_time) > timeout)
{
break;
}
}
-
- utm->time_to_stop = 1;
}
+ utm->time_to_stop = 1;
}
void
-client_connect (uri_tcp_test_main_t * utm)
+client_send_connect (uri_tcp_test_main_t * utm)
{
vl_api_connect_uri_t *cmp;
cmp = vl_msg_api_alloc (sizeof (*cmp));
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & cmp);
}
+int
+client_connect (uri_tcp_test_main_t * utm)
+{
+ client_send_connect (utm);
+ if (wait_for_state_change (utm, STATE_READY))
+ {
+ clib_warning ("Connect failed");
+ return -1;
+ }
+ return 0;
+}
+
void
-client_disconnect (uri_tcp_test_main_t * utm)
+client_send_disconnect (uri_tcp_test_main_t * utm)
{
session_t *connected_session;
vl_api_disconnect_session_t *dmp;
memset (dmp, 0, sizeof (*dmp));
dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
dmp->client_index = utm->my_client_index;
- dmp->session_index = connected_session->vpp_session_index;
- dmp->session_thread_index = connected_session->vpp_session_thread;
+ dmp->handle = connected_session->vpp_session_handle;
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & dmp);
}
+int
+client_disconnect (uri_tcp_test_main_t * utm)
+{
+ client_send_disconnect (utm);
+ if (wait_for_state_change (utm, STATE_START))
+ {
+ clib_warning ("Disconnect failed");
+ return -1;
+ }
+ return 0;
+}
+
static void
client_test (uri_tcp_test_main_t * utm)
{
int i;
- client_connect (utm);
+ if (application_attach (utm))
+ return;
- if (wait_for_state_change (utm, STATE_READY))
+ if (client_connect (utm))
{
+ application_detach (utm);
return;
}
/* Disconnect */
client_disconnect (utm);
+
+ application_detach (utm);
}
static void
vl_api_bind_uri_reply_t_handler (vl_api_bind_uri_reply_t * mp)
{
uri_tcp_test_main_t *utm = &uri_tcp_test_main;
- svm_fifo_segment_create_args_t _a, *a = &_a;
- int rv;
if (mp->retval)
{
- clib_warning ("bind failed: %d", mp->retval);
+ clib_warning ("bind failed: %s", format_api_error,
+ clib_net_to_host_u32 (mp->retval));
utm->state = STATE_FAILED;
return;
}
- if (mp->segment_name_length == 0)
- {
- clib_warning ("segment_name_length zero");
- return;
- }
-
- a->segment_name = (char *) mp->segment_name;
- a->segment_size = mp->segment_size;
-
- ASSERT (mp->server_event_queue_address);
-
- /* Attach to the segment vpp created */
- rv = svm_fifo_segment_attach (a);
- if (rv)
- {
- clib_warning ("svm_fifo_segment_attach ('%s') failed",
- mp->segment_name);
- return;
- }
-
- utm->our_event_queue =
- (unix_shared_memory_queue_t *) mp->server_event_queue_address;
-
utm->state = STATE_READY;
}
utm->state = STATE_START;
}
+u8 *
+format_ip4_address (u8 * s, va_list * args)
+{
+ u8 *a = va_arg (*args, u8 *);
+ return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
+}
+
+u8 *
+format_ip6_address (u8 * s, va_list * args)
+{
+ ip6_address_t *a = va_arg (*args, ip6_address_t *);
+ u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
+
+ i_max_n_zero = ARRAY_LEN (a->as_u16);
+ max_n_zeros = 0;
+ i_first_zero = i_max_n_zero;
+ n_zeros = 0;
+ for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
+ {
+ u32 is_zero = a->as_u16[i] == 0;
+ if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
+ {
+ i_first_zero = i;
+ n_zeros = 0;
+ }
+ n_zeros += is_zero;
+ if ((!is_zero && n_zeros > max_n_zeros)
+ || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
+ {
+ i_max_n_zero = i_first_zero;
+ max_n_zeros = n_zeros;
+ i_first_zero = ARRAY_LEN (a->as_u16);
+ n_zeros = 0;
+ }
+ }
+
+ last_double_colon = 0;
+ for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
+ {
+ if (i == i_max_n_zero && max_n_zeros > 1)
+ {
+ s = format (s, "::");
+ i += max_n_zeros - 1;
+ last_double_colon = 1;
+ }
+ else
+ {
+ s = format (s, "%s%x",
+ (last_double_colon || i == 0) ? "" : ":",
+ clib_net_to_host_u16 (a->as_u16[i]));
+ last_double_colon = 0;
+ }
+ }
+
+ return s;
+}
+
+/* Format an IP46 address. */
+u8 *
+format_ip46_address (u8 * s, va_list * args)
+{
+ ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
+ ip46_type_t type = va_arg (*args, ip46_type_t);
+ int is_ip4 = 1;
+
+ switch (type)
+ {
+ case IP46_TYPE_ANY:
+ is_ip4 = ip46_address_is_ip4 (ip46);
+ break;
+ case IP46_TYPE_IP4:
+ is_ip4 = 1;
+ break;
+ case IP46_TYPE_IP6:
+ is_ip4 = 0;
+ break;
+ }
+
+ return is_ip4 ?
+ format (s, "%U", format_ip4_address, &ip46->ip4) :
+ format (s, "%U", format_ip6_address, &ip46->ip6);
+}
+
static void
vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
{
svm_fifo_t *rx_fifo, *tx_fifo;
session_t *session;
static f64 start_time;
- u64 key;
u32 session_index;
+ u8 *ip_str;
if (start_time == 0.0)
start_time = clib_time_now (&utm->clib_time);
+ ip_str = format (0, "%U", format_ip46_address, &mp->ip, mp->is_ip4);
+ clib_warning ("Accepted session from: %s:%d", ip_str,
+ clib_net_to_host_u16 (mp->port));
utm->vpp_event_queue = (unix_shared_memory_queue_t *)
mp->vpp_event_queue_address;
session->server_tx_fifo = tx_fifo;
/* Add it to lookup table */
- key = (((u64) mp->session_thread_index) << 32) | (u64) mp->session_index;
- hash_set (utm->session_index_by_vpp_handles, key, session_index);
+ hash_set (utm->session_index_by_vpp_handles, mp->handle, session_index);
utm->state = STATE_READY;
rmp = vl_msg_api_alloc (sizeof (*rmp));
memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_ACCEPT_SESSION_REPLY);
- rmp->session_type = mp->session_type;
- rmp->session_index = mp->session_index;
- rmp->session_thread_index = mp->session_thread_index;
+ rmp->handle = mp->handle;
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & rmp);
}
{
svm_fifo_t *rx_fifo, *tx_fifo;
int n_read;
-
session_fifo_event_t evt;
unix_shared_memory_queue_t *q;
int rv, bytes;
rx_fifo = e->fifo;
tx_fifo = utm->sessions[rx_fifo->client_session_index].server_tx_fifo;
- bytes = e->enqueue_length;
+ bytes = svm_fifo_max_dequeue (rx_fifo);
+ /* Allow enqueuing of a new event */
+ svm_fifo_unset_event (rx_fifo);
+
+ if (bytes == 0)
+ return;
+
+ /* Read the bytes */
do
{
- n_read = svm_fifo_dequeue_nowait (rx_fifo, 0, vec_len (utm->rx_buf),
+ n_read = svm_fifo_dequeue_nowait (rx_fifo, vec_len (utm->rx_buf),
utm->rx_buf);
+ if (n_read > 0)
+ bytes -= n_read;
+
+ if (utm->drop_packets)
+ continue;
/* Reflect if a non-drop session */
- if (!utm->drop_packets && n_read > 0)
+ if (n_read > 0)
{
do
{
- rv = svm_fifo_enqueue_nowait (tx_fifo, 0, n_read, utm->rx_buf);
+ rv = svm_fifo_enqueue_nowait (tx_fifo, n_read, utm->rx_buf);
}
- while (rv == -2 && !utm->time_to_stop);
-
- /* Fabricate TX event, send to vpp */
- evt.fifo = tx_fifo;
- evt.event_type = FIFO_EVENT_SERVER_TX;
- /* $$$$ for event logging */
- evt.enqueue_length = n_read;
- evt.event_id = e->event_id;
- q = utm->vpp_event_queue;
- unix_shared_memory_queue_add (q, (u8 *) & evt,
- 0 /* do wait for mutex */ );
- }
+ while (rv <= 0 && !utm->time_to_stop);
- if (n_read > 0)
- bytes -= n_read;
+ /* If event wasn't set, add one */
+ if (svm_fifo_set_event (tx_fifo))
+ {
+ /* Fabricate TX event, send to vpp */
+ evt.fifo = tx_fifo;
+ evt.event_type = FIFO_EVENT_APP_TX;
+ evt.event_id = e->event_id;
+
+ q = utm->vpp_event_queue;
+ unix_shared_memory_queue_add (q, (u8 *) & evt,
+ 0 /* do wait for mutex */ );
+ }
+ }
}
while ((n_read < 0 || bytes > 0) && !utm->time_to_stop);
}
0 /* nowait */ );
switch (e->event_type)
{
- case FIFO_EVENT_SERVER_RX:
+ case FIFO_EVENT_APP_RX:
server_handle_fifo_event_rx (utm, e);
break;
- case FIFO_EVENT_SERVER_EXIT:
+ case FIFO_EVENT_DISCONNECT:
return;
default:
}
void
-server_bind (uri_tcp_test_main_t * utm)
+server_send_listen (uri_tcp_test_main_t * utm)
{
vl_api_bind_uri_t *bmp;
- u32 fifo_size = 3 << 20;
bmp = vl_msg_api_alloc (sizeof (*bmp));
memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
bmp->client_index = utm->my_client_index;
bmp->context = ntohl (0xfeedface);
- bmp->initial_segment_size = 256 << 20; /* size of initial segment */
- bmp->options[SESSION_OPTIONS_FLAGS] =
- SESSION_OPTIONS_FLAGS_USE_FIFO | SESSION_OPTIONS_FLAGS_ADD_SEGMENT;
- bmp->options[SESSION_OPTIONS_RX_FIFO_SIZE] = fifo_size;
- bmp->options[SESSION_OPTIONS_TX_FIFO_SIZE] = fifo_size;
- bmp->options[SESSION_OPTIONS_ADD_SEGMENT_SIZE] = 128 << 20;
memcpy (bmp->uri, utm->uri, vec_len (utm->uri));
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & bmp);
}
+int
+server_listen (uri_tcp_test_main_t * utm)
+{
+ server_send_listen (utm);
+ if (wait_for_state_change (utm, STATE_READY))
+ {
+ clib_warning ("timeout waiting for STATE_READY");
+ return -1;
+ }
+ return 0;
+}
+
void
-server_unbind (uri_tcp_test_main_t * utm)
+server_send_unbind (uri_tcp_test_main_t * utm)
{
vl_api_unbind_uri_t *ump;
vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & ump);
}
+int
+server_unbind (uri_tcp_test_main_t * utm)
+{
+ server_send_unbind (utm);
+ if (wait_for_state_change (utm, STATE_START))
+ {
+ clib_warning ("timeout waiting for STATE_START");
+ return -1;
+ }
+ return 0;
+}
+
void
server_test (uri_tcp_test_main_t * utm)
{
- /* Bind to uri */
- server_bind (utm);
+ if (application_attach (utm))
+ return;
- if (wait_for_state_change (utm, STATE_READY))
- {
- clib_warning ("timeout waiting for STATE_READY");
- return;
- }
+ /* Bind to uri */
+ if (server_listen (utm))
+ return;
/* Enter handle event loop */
server_handle_event_queue (utm);
/* Cleanup */
- server_unbind (utm);
+ server_send_unbind (utm);
- if (wait_for_state_change (utm, STATE_START))
- {
- clib_warning ("timeout waiting for STATE_START");
- return;
- }
+ application_detach (utm);
fformat (stdout, "Test complete...\n");
}
vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
mp)
{
+ uri_tcp_test_main_t *utm = &uri_tcp_test_main;
+
clib_warning ("retval %d", ntohl (mp->retval));
+ utm->state = STATE_START;
}
#define foreach_uri_msg \
_(DISCONNECT_SESSION, disconnect_session) \
_(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \
_(RESET_SESSION, reset_session) \
-_(MAP_ANOTHER_SEGMENT, map_another_segment)
+_(APPLICATION_ATTACH_REPLY, application_attach_reply) \
+_(APPLICATION_DETACH_REPLY, application_detach_reply) \
+_(MAP_ANOTHER_SEGMENT, map_another_segment) \
void
uri_api_hookup (uri_tcp_test_main_t * utm)
u8 *heap, *uri = 0;
u8 *bind_uri = (u8 *) "tcp://0.0.0.0/1234";
u8 *connect_uri = (u8 *) "tcp://6.0.1.2/1234";
+ u64 bytes_to_send = 64 << 10, mbytes;
u32 tmp;
mheap_t *h;
session_t *session;
drop_packets = 1;
else if (unformat (a, "test"))
test_return_packets = 1;
+ else if (unformat (a, "mbytes %lld", &mbytes))
+ {
+ bytes_to_send = mbytes << 20;
+ }
+ else if (unformat (a, "gbytes %lld", &mbytes))
+ {
+ bytes_to_send = mbytes << 30;
+ }
else
{
fformat (stderr, "%s: usage [master|slave]\n");
utm->segment_main = &svm_fifo_segment_main;
utm->drop_packets = drop_packets;
utm->test_return_packets = test_return_packets;
+ utm->bytes_to_send = bytes_to_send;
setup_signal_handlers ();
uri_api_hookup (utm);
Code Review / vpp.git / blobdiff