#define IS_U_BIT_SET(var) ((var) & (1<<2))
#define MAX_SCTP_CONNECTIONS 8
-#define MAIN_SCTP_SUB_CONN_IDX 0
+#define SCTP_PRIMARY_PATH_IDX 0
#if (VLIB_BUFFER_TRACE_TRAJECTORY)
#define sctp_trajectory_add_start(b, start) \
{
SCTP_SUBCONN_STATE_DOWN = 0,
SCTP_SUBCONN_STATE_UP,
- SCTP_SUBCONN_STATE_ALLOW_HB
+ SCTP_SUBCONN_STATE_ALLOW_HB,
+ SCTP_SUBCONN_AWAITING_SACK,
+ SCTP_SUBCONN_SACK_RECEIVED
};
#define SCTP_INITIAL_SSHTRESH 65535
u32 ssthresh; /**< Slow-start threshold (in bytes), which is used by the
sender to distinguish slow-start and congestion avoidance phases. */
- u32 rtt_ts; /**< USED to hold the timestamp of when the packet has been sent */
+ u64 rtt_ts; /**< USED to hold the timestamp of when the packet has been sent */
u32 RTO; /**< The current retransmission timeout value. */
- u32 SRTT; /**< The current smoothed round-trip time. */
- f32 RTTVAR; /**< The current RTT variation. */
+ u64 SRTT; /**< The current smoothed round-trip time. */
+ f64 RTTVAR; /**< The current RTT variation. */
u32 partially_acked_bytes; /**< The tracking method for increase of cwnd when in
congestion avoidance mode (see Section 7.2.2).*/
Every time the RTT calculation completes (i.e., the DATA chunk is SACK'd),
clear this flag. */
- u32 last_seen; /**< The time to which this destination was last sent a packet to.
+ u64 last_seen; /**< The time to which this destination was last sent a packet to.
This can be used to determine if a HEARTBEAT is needed. */
- u32 last_data_ts; /**< Used to hold the timestamp value of last time we sent a DATA chunk */
+ u64 last_data_ts; /**< Used to hold the timestamp value of last time we sent a DATA chunk */
u8 unacknowledged_hb; /**< Used to track how many unacknowledged heartbeats we had;
If more than SCTP_PATH_MAX_RETRANS then connection is considered unreachable. */
*/
#define SUGGESTED_COOKIE_LIFE_SPAN_INCREMENT 1000
+typedef struct _sctp_user_configuration
+{
+ u8 never_delay_sack;
+ u8 never_bundle;
+
+} sctp_user_configuration_t;
+
typedef struct _sctp_connection
{
+ /** Required for pool_get_aligned */
+ CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
+
sctp_sub_connection_t sub_conn[MAX_SCTP_CONNECTIONS]; /**< Common transport data. First! */
+ sctp_user_configuration_t conn_config; /**< Allows tuning of some SCTP behaviors */
u8 state; /**< SCTP state as per sctp_state_t */
u16 flags; /**< Chunk flag (see sctp_chunks_common_hdr_t) */
u32 overall_err_treshold; /**< The threshold for this association that if the Overall Error Count
reaches will cause this association to be torn down. */
+ u8 init_retransmit_err; /**< Error counter for the INIT transmission phase */
+
u32 peer_rwnd; /**< Current calculated value of the peer's rwnd. */
u32 next_tsn; /**< The next TSN number to be assigned to a new DATA chunk.
1 indicates normal stream
2 indicates last fragment of a user message */
- sctp_options_t snd_opts;
-
u8 forming_association_changed; /**< This is a flag indicating whether the original association has been modified during
the life-span of the association itself. For instance, a new sub-connection might have been added. */
+ sctp_state_cookie_param_t cookie_param; /**< Temporary location to save cookie information; it can be used to
+ when timeout expires and sending again a COOKIE is require. */
+
} sctp_connection_t;
typedef void (sctp_timer_expiration_handler) (u32 conn_index, u32 timer_id);
ip6_address_t * lcl_addr,
ip6_address_t * rmt_addr);
+u8
+sctp_sub_connection_del_ip4 (ip4_address_t * lcl_addr,
+ ip4_address_t * rmt_addr);
+
+u8
+sctp_sub_connection_del_ip6 (ip6_address_t * lcl_addr,
+ ip6_address_t * rmt_addr);
+
+u8 sctp_configure (sctp_user_configuration_t config);
+
void sctp_connection_close (sctp_connection_t * sctp_conn);
void sctp_connection_cleanup (sctp_connection_t * sctp_conn);
void sctp_connection_del (sctp_connection_t * sctp_conn);
u32 sctp_push_header (transport_connection_t * tconn, vlib_buffer_t * b);
void sctp_send_init (sctp_connection_t * sctp_conn);
+void sctp_send_cookie_echo (sctp_connection_t * sctp_conn);
void sctp_send_shutdown (sctp_connection_t * sctp_conn);
void sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, u8 idx,
vlib_buffer_t * b);
void sctp_send_shutdown_complete (sctp_connection_t * sctp_conn, u8 idx,
vlib_buffer_t * b0);
void sctp_send_heartbeat (sctp_connection_t * sctp_conn);
+void sctp_data_retransmit (sctp_connection_t * sctp_conn);
void sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index,
u8 is_ip4);
void sctp_flush_frames_to_output (u8 thread_index);
void sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, u8 idx,
vlib_buffer_t * b, ip4_address_t * ip4_addr,
- ip6_address_t * ip6_addr);
-void
-sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
- u8 idx, vlib_buffer_t * b,
- ip4_address_t * ip4_addr,
- ip6_address_t * ip6_addr);
+ u8 add_ip4, ip6_address_t * ip6_addr,
+ u8 add_ip6);
+void sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
+ u8 idx, vlib_buffer_t * b,
+ ip4_address_t * ip4_addr,
+ ip6_address_t * ip6_addr);
void sctp_prepare_abort_for_collision (sctp_connection_t * sctp_conn, u8 idx,
vlib_buffer_t * b,
ip4_address_t * ip4_addr,
ip6_address_t * ip6_addr);
-void
-sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
- vlib_buffer_t * b, u8 err_cause);
+void sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
+ vlib_buffer_t * b, u8 err_cause);
void sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn, u8 idx,
- vlib_buffer_t * b,
- sctp_state_cookie_param_t * sc);
+ vlib_buffer_t * b, u8 reuse_buffer);
void sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
vlib_buffer_t * b);
void sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, u8 idx,
#define SCTP_MAX_INIT_RETRANS 8 // number of attempts
#define SCTP_HB_INTERVAL 30 * SHZ
#define SCTP_HB_MAX_BURST 1
-
#define SCTP_DATA_IDLE_INTERVAL 15 * SHZ /* 15 seconds; the time-interval after which the connetion is considered IDLE */
-
#define SCTP_TO_TIMER_TICK SCTP_TICK*10 /* Period for converting from SCTP_TICK */
+#define SCTP_CONN_RECOVERY 1 << 1
+#define SCTP_FAST_RECOVERY 1 << 2
+
typedef struct _sctp_lookup_dispatch
{
u8 next, error;
u8 log2_tstamp_clocks_per_tick;
f64 tstamp_ticks_per_clock;
- u32 *time_now;
+ u64 *time_now;
/** per-worker tx buffer free lists */
u32 **tx_buffers;
clib_spinlock_lock_if_init (&sctp_main.half_open_lock);
if (!pool_is_free_index (sctp_main.half_open_connections, conn_index))
tc = pool_elt_at_index (sctp_main.half_open_connections, conn_index);
- tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].subconn_idx = MAIN_SCTP_SUB_CONN_IDX;
+ tc->sub_conn[SCTP_PRIMARY_PATH_IDX].subconn_idx = SCTP_PRIMARY_PATH_IDX;
clib_spinlock_unlock_if_init (&sctp_main.half_open_lock);
return tc;
}
sctp_main_t *sctp_main = vnet_get_sctp_main ();
clib_spinlock_lock_if_init (&sctp_main->half_open_lock);
pool_put_index (sctp_main->half_open_connections,
- tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_c_index);
+ tc->sub_conn[SCTP_PRIMARY_PATH_IDX].c_c_index);
if (CLIB_DEBUG)
- memset (tc, 0xFA, sizeof (*tc));
+ clib_memset (tc, 0xFA, sizeof (*tc));
clib_spinlock_unlock_if_init (&sctp_main->half_open_lock);
}
-always_inline u32
+always_inline u64
sctp_set_time_now (u32 thread_index)
{
sctp_main.time_now[thread_index] = clib_cpu_time_now ()
sctp_half_open_connection_cleanup (sctp_connection_t * tc)
{
/* Make sure this is the owning thread */
- if (tc->sub_conn[MAIN_SCTP_SUB_CONN_IDX].c_thread_index !=
+ if (tc->sub_conn[SCTP_PRIMARY_PATH_IDX].c_thread_index !=
vlib_get_thread_index ())
return 1;
- sctp_timer_reset (tc, MAIN_SCTP_SUB_CONN_IDX, SCTP_TIMER_T1_INIT);
+ sctp_timer_reset (tc, SCTP_PRIMARY_PATH_IDX, SCTP_TIMER_T1_INIT);
sctp_half_open_connection_del (tc);
return 0;
}
return (sctp_connection_t *) sub;
}
-always_inline u32
+always_inline u64
sctp_time_now (void)
{
return sctp_main.time_now[vlib_get_thread_index ()];
sctp_calculate_rto (sctp_connection_t * sctp_conn, u8 conn_idx)
{
/* See RFC4960, 6.3.1. RTO Calculation */
- u32 RTO = 0;
- f32 RTTVAR = 0;
- u32 now = sctp_time_now ();
- u32 prev_ts = sctp_conn->sub_conn[conn_idx].rtt_ts;
- u32 R = prev_ts - now;
+ u64 RTO = 0;
+ f64 RTTVAR = 0;
+ u64 now = sctp_time_now ();
+ u64 prev_ts = sctp_conn->sub_conn[conn_idx].rtt_ts;
+ u64 R = prev_ts - now;
if (sctp_conn->sub_conn[conn_idx].RTO == 0) // C1: Let's initialize our RTO
{
always_inline u8
sctp_data_subconn_select (sctp_connection_t * sctp_conn)
{
- u32 sub = MAIN_SCTP_SUB_CONN_IDX;
- u8 i, cwnd = sctp_conn->sub_conn[MAIN_SCTP_SUB_CONN_IDX].cwnd;
+ u32 sub = SCTP_PRIMARY_PATH_IDX;
+ u8 i, cwnd = sctp_conn->sub_conn[SCTP_PRIMARY_PATH_IDX].cwnd;
for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
{
if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
return i;
}
clib_warning ("Did not find a sub-connection; defaulting to %u",
- MAIN_SCTP_SUB_CONN_IDX);
- return MAIN_SCTP_SUB_CONN_IDX;
+ SCTP_PRIMARY_PATH_IDX);
+ return SCTP_PRIMARY_PATH_IDX;
}
always_inline u8
return i;
}
clib_warning ("Did not find a sub-connection; defaulting to %u",
- MAIN_SCTP_SUB_CONN_IDX);
- return MAIN_SCTP_SUB_CONN_IDX;
+ SCTP_PRIMARY_PATH_IDX);
+ return SCTP_PRIMARY_PATH_IDX;
}
/**
update_smallest_pmtu_idx (sctp_connection_t * sctp_conn)
{
u8 i;
- u8 smallest_pmtu_index = MAIN_SCTP_SUB_CONN_IDX;
+ u8 smallest_pmtu_index = SCTP_PRIMARY_PATH_IDX;
for (i = 1; i < MAX_SCTP_CONNECTIONS; i++)
{
always_inline u8
cwnd_fully_utilized (sctp_connection_t * sctp_conn, u8 idx)
{
+ if (sctp_conn->sub_conn[idx].cwnd == 0)
+ return 1;
return 0;
}
update_cwnd (sctp_connection_t * sctp_conn)
{
u8 i;
+ u32 inflight = sctp_conn->next_tsn - sctp_conn->last_unacked_tsn;
for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
{
sctp_conn->sub_conn[i].cwnd =
clib_min (sctp_conn->sub_conn[i].PMTU, 1);
}
+
+ /* Section 6.1; point (D) */
+ if ((inflight + SCTP_RTO_BURST * sctp_conn->sub_conn[i].PMTU) <
+ sctp_conn->sub_conn[i].cwnd)
+ sctp_conn->sub_conn[i].cwnd =
+ inflight + SCTP_RTO_BURST * sctp_conn->sub_conn[i].PMTU;
}
}
Code Review / vpp.git / blobdiff