/* VNET_API_ERROR_FOO -> "Foo" hash table */
uword *error_string_by_error_number;
- /* convenience */
- svm_fifo_segment_main_t *segment_main;
+ svm_fifo_segment_main_t segment_main;
u8 *connect_test_data;
uword
unformat_uri (unformat_input_t * input, va_list * args)
{
- session_endpoint_extended_t *sep = va_arg (*args,
- session_endpoint_extended_t *);
+ session_endpoint_cfg_t *sep = va_arg (*args, session_endpoint_cfg_t *);
u32 port;
char *tmp;
{
vl_api_application_attach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
bmp->client_index = utm->my_client_index;
bmp->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_ADD_SEGMENT;
bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
- bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
bmp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = 2;
bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = utm->fifo_size;
bmp->options[APP_OPTIONS_TX_FIFO_SIZE] = utm->fifo_size;
{
vl_api_application_detach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
bmp->client_index = utm->my_client_index;
vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
mp)
{
- udp_echo_main_t *utm = &udp_echo_main;
svm_fifo_segment_create_args_t _a = { 0 }, *a = &_a;
+ udp_echo_main_t *utm = &udp_echo_main;
+ svm_fifo_segment_main_t *sm = &utm->segment_main;
int rv;
if (mp->retval)
ASSERT (mp->app_event_queue_address);
/* Attach to the segment vpp created */
- rv = svm_fifo_segment_attach (a);
+ rv = svm_fifo_segment_attach (sm, a);
if (rv)
{
clib_warning ("svm_fifo_segment_attach ('%s') failed",
else
{
/* We don't do anything with the data, drop it */
- actual_transfer = svm_fifo_max_dequeue (rx_fifo);
+ actual_transfer = svm_fifo_max_dequeue_cons (rx_fifo);
svm_fifo_dequeue_drop (rx_fifo, actual_transfer);
}
}
tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - utm->sessions;
session->session_index = session_index;
- /* Cut-through case */
- if (mp->server_event_queue_address)
- {
- clib_warning ("cut-through session");
- session->vpp_evt_q = uword_to_pointer (mp->client_event_queue_address,
- svm_msg_q_t *);
- sleep (1);
- rx_fifo->master_session_index = session_index;
- tx_fifo->master_session_index = session_index;
- utm->cut_through_session_index = session_index;
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
- session->is_dgram = 0;
-
- rv = pthread_create (&utm->cut_through_thread_handle,
- NULL /*attr */ , cut_through_thread_fn, 0);
- if (rv)
- {
- clib_warning ("pthread_create returned %d", rv);
- rv = VNET_API_ERROR_SYSCALL_ERROR_1;
- }
- }
- else
- {
- rx_fifo->client_session_index = session_index;
- tx_fifo->client_session_index = session_index;
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
- clib_memcpy (&session->transport.rmt_ip, mp->ip,
- sizeof (ip46_address_t));
- session->transport.is_ip4 = mp->is_ip4;
- session->transport.rmt_port = mp->port;
- }
+ rx_fifo->client_session_index = session_index;
+ tx_fifo->client_session_index = session_index;
+ session->rx_fifo = rx_fifo;
+ session->tx_fifo = tx_fifo;
+ clib_memcpy_fast (&session->transport.rmt_ip, mp->ip,
+ sizeof (ip46_address_t));
+ session->transport.is_ip4 = mp->is_ip4;
+ session->transport.rmt_port = mp->port;
hash_set (utm->session_index_by_vpp_handles, mp->handle, session_index);
if (pool_elts (utm->sessions) && (pool_elts (utm->sessions) % 20000) == 0)
{
udp_echo_main_t *utm = &udp_echo_main;
unformat_input_t _input, *input = &_input;
- session_endpoint_extended_t _sep, *sep = &_sep;
+ session_endpoint_cfg_t _sep, *sep = &_sep;
app_session_t *session;
ASSERT (utm->i_am_server == 0);
session->tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
/* Cut-through case */
- if (mp->client_event_queue_address)
+ if (mp->ct_rx_fifo)
{
clib_warning ("cut-through session");
- session->vpp_evt_q = uword_to_pointer (mp->server_event_queue_address,
+ session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
svm_msg_q_t *);
- utm->ct_event_queue = uword_to_pointer (mp->client_event_queue_address,
- svm_msg_q_t *);
utm->cut_through_session_index = session->session_index;
session->is_dgram = 0;
sleep (1);
session->rx_fifo->client_session_index = session->session_index;
session->tx_fifo->client_session_index = session->session_index;
+ /* TODO use ct fifos */
}
else
{
session->rx_fifo->client_session_index = session->session_index;
session->tx_fifo->client_session_index = session->session_index;
- clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
- sizeof (ip46_address_t));
+ clib_memcpy_fast (&session->transport.lcl_ip, mp->lcl_ip,
+ sizeof (ip46_address_t));
session->transport.is_ip4 = mp->is_ip4;
session->transport.lcl_port = mp->lcl_port;
return;
}
unformat_free (input);
- clib_memcpy (&session->transport.rmt_ip, &sep->ip,
- sizeof (ip46_address_t));
+ clib_memcpy_fast (&session->transport.rmt_ip, &sep->ip,
+ sizeof (ip46_address_t));
session->transport.rmt_port = sep->port;
session->is_dgram = !utm->is_connected;
}
tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
session_index = session - utm->sessions;
rx_fifo->client_session_index = session_index;
tx_fifo->client_session_index = session_index;
session->rx_fifo = rx_fifo;
session->tx_fifo = tx_fifo;
- clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
- sizeof (ip46_address_t));
+ clib_memcpy_fast (&session->transport.lcl_ip, mp->lcl_ip,
+ sizeof (ip46_address_t));
session->transport.is_ip4 = mp->lcl_is_ip4;
session->transport.lcl_port = mp->lcl_port;
session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
{
vl_api_connect_uri_t *cmp;
cmp = vl_msg_api_alloc (sizeof (*cmp));
- memset (cmp, 0, sizeof (*cmp));
+ clib_memset (cmp, 0, sizeof (*cmp));
cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
cmp->client_index = utm->my_client_index;
u8 *test_data = utm->connect_test_data;
u32 bytes_to_snd, enq_space, min_chunk;
- session_evt_type_t et = FIFO_EVENT_APP_TX;
int written;
test_buf_len = vec_len (test_data);
test_buf_offset = utm->bytes_sent % test_buf_len;
bytes_this_chunk = clib_min (test_buf_len - test_buf_offset,
utm->bytes_to_send);
- enq_space = svm_fifo_max_enqueue (s->tx_fifo);
+ enq_space = svm_fifo_max_enqueue_prod (s->tx_fifo);
bytes_this_chunk = clib_min (bytes_this_chunk, enq_space);
- et += (s->session_index == utm->cut_through_session_index);
-
- if (s->is_dgram)
- written = app_send_dgram_raw (s->tx_fifo, &s->transport, s->vpp_evt_q,
- test_data + test_buf_offset,
- bytes_this_chunk, et, SVM_Q_WAIT);
- else
- written = app_send_stream_raw (s->tx_fifo, s->vpp_evt_q,
- test_data + test_buf_offset,
- bytes_this_chunk, et, SVM_Q_WAIT);
+ written = app_send (s, test_data + test_buf_offset, bytes_this_chunk,
+ SVM_Q_WAIT);
if (written > 0)
{
utm->bytes_to_send -= written;
wait_for_state_change (utm, STATE_DETACHED);
}
-static void
-vl_api_bind_uri_reply_t_handler (vl_api_bind_uri_reply_t * mp)
-{
- udp_echo_main_t *utm = &udp_echo_main;
- svm_fifo_t *rx_fifo, *tx_fifo;
- app_session_t *session;
- u32 session_index;
-
- if (mp->retval)
- {
- clib_warning ("bind failed: %d", mp->retval);
- utm->state = STATE_FAILED;
- return;
- }
-
- rx_fifo = uword_to_pointer (mp->rx_fifo, svm_fifo_t *);
- tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
-
- pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
- session_index = session - utm->sessions;
-
- rx_fifo->client_session_index = session_index;
- tx_fifo->client_session_index = session_index;
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
- clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
- sizeof (ip46_address_t));
- session->transport.is_ip4 = mp->lcl_is_ip4;
- session->transport.lcl_port = mp->lcl_port;
- session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
-
- utm->state = utm->is_connected ? STATE_BOUND : STATE_READY;
-}
-
static void
vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
{
- udp_echo_main_t *utm = &udp_echo_main;
svm_fifo_segment_create_args_t _a, *a = &_a;
+ udp_echo_main_t *utm = &udp_echo_main;
+ svm_fifo_segment_main_t *sm = &utm->segment_main;
svm_fifo_segment_private_t *seg;
- u8 *seg_name;
int rv;
- memset (a, 0, sizeof (*a));
+ clib_memset (a, 0, sizeof (*a));
a->segment_name = (char *) mp->segment_name;
a->segment_size = mp->segment_size;
/* Attach to the segment vpp created */
- rv = svm_fifo_segment_attach (a);
+ rv = svm_fifo_segment_attach (sm, a);
if (rv)
{
clib_warning ("svm_fifo_segment_attach ('%s') failed",
mp->segment_name);
return;
}
- seg = svm_fifo_segment_get_segment (a->new_segment_indices[0]);
+ seg = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
clib_warning ("Mapped new segment '%s' size %d", seg->ssvm.name,
seg->ssvm.ssvm_size);
- seg_name = format (0, "%s", (char *) mp->segment_name);
- hash_set_mem (utm->segments_table, seg_name, a->new_segment_indices[0]);
- vec_free (seg_name);
+ hash_set (utm->segments_table, clib_net_to_host_u64 (mp->segment_handle),
+ a->new_segment_indices[0]);
}
static void
vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
{
udp_echo_main_t *utm = &udp_echo_main;
+ svm_fifo_segment_main_t *sm = &utm->segment_main;
svm_fifo_segment_private_t *seg;
- u64 *seg_indexp;
- u8 *seg_name;
-
+ uword *seg_indexp;
+ u64 segment_handle;
- seg_name = format (0, "%s", mp->segment_name);
- seg_indexp = hash_get_mem (utm->segments_table, seg_name);
+ segment_handle = clib_net_to_host_u64 (mp->segment_handle);
+ seg_indexp = hash_get (utm->segments_table, segment_handle);
if (!seg_indexp)
{
- clib_warning ("segment not mapped: %s", seg_name);
+ clib_warning ("segment not mapped: %s", segment_handle);
return;
}
- hash_unset_mem (utm->segments_table, seg_name);
- seg = svm_fifo_segment_get_segment ((u32) seg_indexp[0]);
- svm_fifo_segment_delete (seg);
- clib_warning ("Unmapped segment '%s'", seg_name);
- vec_free (seg_name);
+ hash_unset (utm->segments_table, segment_handle);
+ seg = svm_fifo_segment_get_segment (sm, (u32) seg_indexp[0]);
+ svm_fifo_segment_delete (sm, seg);
+ clib_warning ("Unmapped segment '%s'", segment_handle);
}
static void
}
#define foreach_tcp_echo_msg \
-_(BIND_URI_REPLY, bind_uri_reply) \
_(UNBIND_URI_REPLY, unbind_uri_reply) \
_(MAP_ANOTHER_SEGMENT, map_another_segment) \
_(UNMAP_SEGMENT, unmap_segment) \
app_session_t *session;
int rv;
u32 max_dequeue, offset, max_transfer, rx_buf_len;
- session_evt_type_t et = FIFO_EVENT_APP_TX;
session = pool_elt_at_index (utm->sessions, session_index);
rx_buf_len = vec_len (utm->rx_buf);
rx_fifo = session->rx_fifo;
tx_fifo = session->tx_fifo;
- et += (session->session_index == utm->cut_through_session_index);
- max_dequeue = svm_fifo_max_dequeue (rx_fifo);
+ max_dequeue = svm_fifo_max_dequeue_cons (rx_fifo);
/* Allow enqueuing of a new event */
svm_fifo_unset_event (rx_fifo);
offset = 0;
do
{
- if (session->is_dgram)
- rv = app_send_dgram_raw (tx_fifo, &session->transport,
- session->vpp_evt_q,
- &utm->rx_buf[offset], n_read, et,
- SVM_Q_WAIT);
- else
- rv = app_send_stream_raw (tx_fifo, session->vpp_evt_q,
- &utm->rx_buf[offset], n_read, et,
- SVM_Q_WAIT);
+ rv = app_send (session, &utm->rx_buf[offset], n_read,
+ SVM_Q_WAIT);
if (rv > 0)
{
n_read -= rv;
/* If event wasn't set, add one */
if (svm_fifo_set_event (tx_fifo))
- app_send_io_evt_to_vpp (session->vpp_evt_q, tx_fifo,
- et, SVM_Q_WAIT);
+ app_send_io_evt_to_vpp (session->vpp_evt_q,
+ tx_fifo->master_session_index,
+ SESSION_IO_EVT_TX, SVM_Q_WAIT);
}
}
while ((n_read < 0 || max_dequeue > 0) && !utm->time_to_stop);
e = svm_msg_q_msg_data (mq, &msg);
switch (e->event_type)
{
- case FIFO_EVENT_APP_RX:
- server_handle_fifo_event_rx (utm, e->fifo->client_session_index);
- break;
- case SESSION_IO_EVT_CT_TX:
+ case SESSION_IO_EVT_RX:
+ server_handle_fifo_event_rx (utm, e->session_index);
break;
default:
vl_api_unbind_uri_t *ump;
ump = vl_msg_api_alloc (sizeof (*ump));
- memset (ump, 0, sizeof (*ump));
+ clib_memset (ump, 0, sizeof (*ump));
ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
ump->client_index = utm->my_client_index;
vl_api_bind_uri_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
- memset (bmp, 0, sizeof (*bmp));
+ clib_memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
bmp->client_index = utm->my_client_index;
main (int argc, char **argv)
{
udp_echo_main_t *utm = &udp_echo_main;
+ svm_fifo_segment_main_t *sm = &utm->segment_main;
u8 *uri = (u8 *) "udp://6.0.1.1/1234";
unformat_input_t _argv, *a = &_argv;
int i_am_server = 1;
clib_mem_init_thread_safe (0, 256 << 20);
- svm_fifo_segment_main_init (0x200000000ULL, 20);
+ svm_fifo_segment_main_init (sm, HIGH_SEGMENT_BASEVA, 20);
vec_validate (utm->rx_buf, 128 << 10);
utm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
utm->my_pid = getpid ();
utm->configured_segment_size = 1 << 20;
- utm->segments_table = hash_create_vec (0, sizeof (u8), sizeof (u64));
utm->have_return = 1;
utm->bytes_to_send = 1024;
utm->fifo_size = 128 << 10;
- utm->segment_main = &svm_fifo_segment_main;
utm->cut_through_session_index = ~0;
clib_time_init (&utm->clib_time);
for (i = 0; i < 200000; i++)
{
pool_get (utm->sessions, session);
- memset (session, 0, sizeof (*session));
+ clib_memset (session, 0, sizeof (*session));
}
for (i = 0; i < 200000; i++)
pool_put_index (utm->sessions, i);