void *iface_ip;
pool_get (tm->listener_pool, listener);
- memset (listener, 0, sizeof (*listener));
+ clib_memset (listener, 0, sizeof (*listener));
listener->c_c_index = listener - tm->listener_pool;
listener->c_lcl_port = lcl->port;
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
pool_put_index (tm->listener_pool, listener_index);
}
clib_spinlock_lock_if_init (&tm->half_open_lock);
pool_put_index (tm->half_open_connections, tc->c_c_index);
if (CLIB_DEBUG)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
clib_spinlock_unlock_if_init (&tm->half_open_lock);
}
tcp_connection_t *tc = 0;
ASSERT (vlib_get_thread_index () == 0);
pool_get (tm->half_open_connections, tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->c_c_index = tc - tm->half_open_connections;
return tc;
}
/* Try to remove the half-open connection. If this is not the owning
* thread, tc won't be removed. Retransmit or establish timers will
* eventually expire and call again cleanup on the right thread. */
- tcp_half_open_connection_cleanup (tc);
+ if (tcp_half_open_connection_cleanup (tc))
+ tc->flags |= TCP_CONN_HALF_OPEN_DONE;
}
else
{
/* Poison the entry */
if (CLIB_DEBUG > 0)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
pool_put (tm->connections[thread_index], tc);
}
}
tcp_connection_t *tc;
pool_get (tm->connections[thread_index], tc);
- memset (tc, 0, sizeof (*tc));
+ clib_memset (tc, 0, sizeof (*tc));
tc->c_c_index = tc - tm->connections[thread_index];
tc->c_thread_index = thread_index;
return tc;
tc->state = TCP_STATE_CLOSED;
break;
case TCP_STATE_SYN_RCVD:
+ tcp_connection_timers_reset (tc);
tcp_send_fin (tc);
tc->state = TCP_STATE_FIN_WAIT_1;
+ tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
break;
case TCP_STATE_ESTABLISHED:
if (!session_tx_fifo_max_dequeue (&tc->connection))
if (tc->c_is_ip4)
{
ip4_tcp_hdr_t hdr;
- memset (&hdr, 0, sizeof (hdr));
+ clib_memset (&hdr, 0, sizeof (hdr));
hdr.ip.protocol = IP_PROTOCOL_TCP;
hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32;
hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32;
else
{
ip6_tcp_hdr_t hdr;
- memset (&hdr, 0, sizeof (hdr));
+ clib_memset (&hdr, 0, sizeof (hdr));
hdr.ip.protocol = IP_PROTOCOL_TCP;
clib_memcpy (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
sizeof (ip6_address_t));
tc->snd_una_max - tc->iss);
s = format (s, " rcv_nxt %u rcv_las %u\n",
tc->rcv_nxt - tc->irs, tc->rcv_las - tc->irs);
- s = format (s, " snd_wnd %u rcv_wnd %u snd_wl1 %u snd_wl2 %u\n",
- tc->snd_wnd, tc->rcv_wnd, tc->snd_wl1 - tc->irs,
+ s = format (s, " snd_wnd %u rcv_wnd %u rcv_wscale %u ",
+ tc->snd_wnd, tc->rcv_wnd, tc->rcv_wscale);
+ s = format (s, "snd_wl1 %u snd_wl2 %u\n", tc->snd_wl1 - tc->irs,
tc->snd_wl2 - tc->iss);
s = format (s, " flight size %u out space %u cc space %u rcv_wnd_av %u\n",
tcp_flight_size (tc), tcp_available_output_snd_space (tc),
s = format (s, "sacked_bytes %u last_sacked_bytes %u lost_bytes %u\n",
sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes);
s = format (s, " last_bytes_delivered %u high_sacked %u snd_una_adv %u\n",
- sb->last_bytes_delivered, sb->high_sacked, sb->snd_una_adv);
+ sb->last_bytes_delivered, sb->high_sacked - tc->iss,
+ sb->snd_una_adv);
s = format (s, " cur_rxt_hole %u high_rxt %u rescue_rxt %u",
- sb->cur_rxt_hole, sb->high_rxt, sb->rescue_rxt);
+ sb->cur_rxt_hole, sb->high_rxt - tc->iss,
+ sb->rescue_rxt - tc->iss);
hole = scoreboard_first_hole (sb);
if (hole)
* @param tc tcp connection
* @return number of bytes session is allowed to write
*/
-static u32
-tcp_snd_space (tcp_connection_t * tc)
+static inline u32
+tcp_snd_space_inline (tcp_connection_t * tc)
{
int snd_space, snt_limited;
return 0;
}
+u32
+tcp_snd_space (tcp_connection_t * tc)
+{
+ return tcp_snd_space_inline (tc);
+}
+
static u32
tcp_session_send_space (transport_connection_t * trans_conn)
{
tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
- return clib_min (tcp_snd_space (tc),
+ return clib_min (tcp_snd_space_inline (tc),
tc->snd_wnd - (tc->snd_nxt - tc->snd_una));
}
clib_warning ("FIN was sent and still in CLOSE WAIT. Weird!");
}
+ /* Make sure we don't try to send unsent data */
+ tcp_connection_timers_reset (tc);
+ tcp_cong_recovery_off (tc);
+ tc->snd_una_max = tc->snd_nxt = tc->snd_una;
tcp_send_fin (tc);
tc->state = TCP_STATE_LAST_ACK;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
- if (unformat
- (input, "preallocated-connections %d",
- &tm->preallocated_connections))
+ if (unformat (input, "preallocated-connections %d",
+ &tm->preallocated_connections))
;
else if (unformat (input, "preallocated-half-open-connections %d",
&tm->preallocated_half_open_connections))
else if (unformat (input, "buffer-fail-fraction %f",
&tm->buffer_fail_fraction))
;
+ else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
+ &tm->max_rx_fifo))
+ ;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
ip4_address_t * hi_addr, u32 fib_index,
int is_del);
- memset (&prefix, 0, sizeof (prefix));
+ clib_memset (&prefix, 0, sizeof (prefix));
fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
fib_node_index_t fei;
u32 sw_if_index;
- memset (&prefix, 0, sizeof (prefix));
+ clib_memset (&prefix, 0, sizeof (prefix));
fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
if (!tc)
return s;
- memset (dummy_tc, 0, sizeof (*dummy_tc));
+ clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
tcp_connection_timers_init (dummy_tc);
scoreboard_init (&dummy_tc->sack_sb);
dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
Code Review / vpp.git / blobdiff