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;
return 0;
}
+static 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_session_connected_callback (u32 app_index, u32 api_context,
stream_session_t * s, u8 is_fail)
u32 session_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);
__sync_fetch_and_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);
}
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);
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);
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++)
{
vlib_main_t *vlib_main;
} echo_client_main_t;
+enum
+{
+ ECHO_CLIENTS_STARTING,
+ ECHO_CLIENTS_RUNNING,
+ ECHO_CLIENTS_EXITING
+} echo_clients_test_state_e;
extern echo_client_main_t echo_client_main;
vlib_node_registration_t echo_clients_node;
memset (s, 0xFA, sizeof (*s));
}
-static void
+void
session_free_w_fifos (stream_session_t * s)
{
segment_manager_dealloc_fifos (s->svm_segment_index, s->server_rx_fifo,
s = session_alloc (thread_index);
s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4);
s->session_state = SESSION_STATE_CONNECTING;
- s->enqueue_epoch = ~0;
+ s->enqueue_epoch = (u64) ~ 0;
/* Attach transport to session and vice versa */
s->connection_index = tc->c_index;
* by calling stream_server_flush_enqueue_events () */
session_manager_main_t *smm = vnet_get_session_manager_main ();
u32 thread_index = s->thread_index;
- u32 enqueue_epoch = smm->current_enqueue_epoch[tc->proto][thread_index];
+ u64 enqueue_epoch = smm->current_enqueue_epoch[tc->proto][thread_index];
if (s->enqueue_epoch != enqueue_epoch)
{
* by calling stream_server_flush_enqueue_events () */
session_manager_main_t *smm = vnet_get_session_manager_main ();
u32 thread_index = s->thread_index;
- u32 enqueue_epoch = smm->current_enqueue_epoch[proto][thread_index];
+ u64 enqueue_epoch = smm->current_enqueue_epoch[proto][thread_index];
if (s->enqueue_epoch != enqueue_epoch)
{
clib_rwlock_t *peekers_rw_locks;
/** Per-proto, per-worker enqueue epoch counters */
- u32 *current_enqueue_epoch[TRANSPORT_N_PROTO];
+ u64 *current_enqueue_epoch[TRANSPORT_N_PROTO];
/** Per-proto, per-worker thread vector of sessions to enqueue */
u32 **session_to_enqueue[TRANSPORT_N_PROTO];
stream_session_t *session_alloc (u32 thread_index);
int session_alloc_fifos (segment_manager_t * sm, stream_session_t * s);
void session_free (stream_session_t * s);
+void session_free_w_fifos (stream_session_t * s);
always_inline stream_session_t *
session_get (u32 si, u32 thread_index)
u8 thread_index;
/** To avoid n**2 "one event per frame" check */
- u8 enqueue_epoch;
+ u64 enqueue_epoch;
/** svm segment index where fifos were allocated */
u32 svm_segment_index;
/** Port for connection. Overlaps thread_index/enqueue_epoch */
u16 port;
+ /** Partly overlaps enqueue_epoch */
+ u8 pad_epoch[7];
+
/** Segment index where fifos were allocated */
u32 svm_segment_index;
tcp_retransmit_timer_force_update (tc);
if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
- return;
+ {
+ /* Out of buffers so program fin retransmit ASAP */
+ tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
+ tc->flags |= TCP_CONN_FINSNT;
+ tc->snd_una_max += 1;
+ tc->snd_nxt = tc->snd_una_max;
+ return;
+ }
+
b = vlib_get_buffer (vm, bi);
tcp_init_buffer (vm, b);
fin_snt = tc->flags & TCP_CONN_FINSNT;
{
clib_rwlock_writer_lock (&tm->half_open_rwlock);
pool_get (tm->half_open_ctx_pool, ctx);
+ ctx_index = ctx - tm->half_open_ctx_pool;
clib_rwlock_writer_unlock (&tm->half_open_rwlock);
}
else
/* reader lock assumption: only main thread will call pool_get */
clib_rwlock_reader_lock (&tm->half_open_rwlock);
pool_get (tm->half_open_ctx_pool, ctx);
+ ctx_index = ctx - tm->half_open_ctx_pool;
clib_rwlock_reader_unlock (&tm->half_open_rwlock);
}
memset (ctx, 0, sizeof (*ctx));
- ctx_index = ctx - tm->half_open_ctx_pool;
return ctx_index;
}
{
TLS_DBG (1, "failed to notify app");
tls_disconnect (ctx->tls_ctx_handle, vlib_get_thread_index ());
+ session_free_w_fifos (app_session);
+ return -1;
}
session_lookup_add_connection (&ctx->connection,