net: tcp: Implement randomized retransmission timeouts

It can happen that two similar stacks enter a retransmission cycle
due to a packet collision. If the transmission timeout is the same
both stacks will retry at the same moment resulting in another
collision.

By introducing a randomized retry timeout, the chance of
a second collision is reduced and it reduces furter the more
retransmissions occur.

Signed-off-by: Sjors Hettinga <[email protected]>

Author: ssharks

subsys/net/ip/Kconfig

@@ -412,6 +412,18 @@ config NET_TCP_RETRY_COUNT
 	  Should a retransmission timeout occur, the receive callback is
 	  called with -ECONNRESET error code and the context is dereferenced.
 
+config NET_TCP_RANDOMIZED_RTO
+	bool "Use a randomized retransmission time"
+	default y
+	depends on NET_TCP
+	help
+	  It can happen that two similar stacks enter a retransmission cycle
+	  due to a packet collision. If the transmission timeout is the same
+	  both stacks will retry at the same moment resulting in another
+	  collision. By introducing a randomized retry timeout, the chance of
+	  a second collision is reduced and it reduces furter the more
+	  retransmissions occur.
+
 config NET_TCP_MAX_SEND_WINDOW_SIZE
 	int "Maximum sending window size to use"
 	depends on NET_TCP

subsys/net/ip/tcp.c

@@ -28,22 +28,23 @@ LOG_MODULE_REGISTER(net_tcp, CONFIG_NET_TCP_LOG_LEVEL);
 
 #define ACK_TIMEOUT_MS CONFIG_NET_TCP_ACK_TIMEOUT
 #define ACK_TIMEOUT K_MSEC(ACK_TIMEOUT_MS)
-/* Allow for (tcp_retries + 1) transmissions
- * 1 + 2... + 2^n < 2^(n+1)
- * The last retransmission cycle takes only 1 tcp_rto
- */
-#define FIN_TIMEOUT_MS (tcp_rto * (1 + (1 << (tcp_retries + 1))))
-#define FIN_TIMEOUT K_MSEC(FIN_TIMEOUT_MS)
+#define FIN_TIMEOUT K_MSEC(tcp_fin_timeout_ms)
 #define ACK_DELAY K_MSEC(100)
 
 static int tcp_rto = CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT;
 static int tcp_retries = CONFIG_NET_TCP_RETRY_COUNT;
+static int tcp_fin_timeout_ms;
 static int tcp_window =
 #if (CONFIG_NET_TCP_MAX_RECV_WINDOW_SIZE != 0)
 	CONFIG_NET_TCP_MAX_RECV_WINDOW_SIZE;
 #else
 	(CONFIG_NET_BUF_RX_COUNT * CONFIG_NET_BUF_DATA_SIZE) / 3;
 #endif
+#ifdef CONFIG_NET_TCP_RANDOMIZED_RTO
+#define TCP_RTO_MS (conn->rto)
+#else
+#define TCP_RTO_MS (tcp_rto)
+#endif
 
 static sys_slist_t tcp_conns = SYS_SLIST_STATIC_INIT(&tcp_conns);
 
@@ -352,6 +353,28 @@ static void tcp_send(struct net_pkt *pkt)
 	tcp_pkt_unref(pkt);
 }
 
+static void tcp_derive_rto(struct tcp *conn)
+{
+#ifdef CONFIG_NET_TCP_RANDOMIZED_RTO
+	/* Compute a randomized rto 1 and 1.5 times tcp_rto */
+	uint32_t gain;
+	uint8_t gain8;
+	uint32_t rto;
+
+	/* Getting random is computational expensive, so only use 8 bits */
+	sys_rand_get(&gain8, sizeof(uint8_t));
+
+	gain = (uint32_t)gain8;
+	gain += 1 << 9;
+
+	rto = (uint32_t)tcp_rto;
+	rto = (gain * rto) >> 9;
+	conn->rto = (uint16_t)rto;
+#else
+	ARG_UNUSED(conn);
+#endif
+}
+
 static void tcp_send_queue_flush(struct tcp *conn)
 {
 	struct net_pkt *pkt;
@@ -517,7 +540,7 @@ static bool tcp_send_process_no_lock(struct tcp *conn)
 
 	if (conn->in_retransmission) {
 		k_work_reschedule_for_queue(&tcp_work_q, &conn->send_timer,
-					    K_MSEC(tcp_rto));
+					    K_MSEC(TCP_RTO_MS));
 	} else if (local && !sys_slist_is_empty(&conn->send_queue)) {
 		k_work_reschedule_for_queue(&tcp_work_q, &conn->send_timer,
 					    K_NO_WAIT);
@@ -566,7 +589,7 @@ static void tcp_send_timer_cancel(struct tcp *conn)
 	} else {
 		conn->send_retries = tcp_retries;
 		k_work_reschedule_for_queue(&tcp_work_q, &conn->send_timer,
-					    K_MSEC(tcp_rto));
+					    K_MSEC(TCP_RTO_MS));
 	}
 }
 
@@ -1182,7 +1205,7 @@ static int tcp_send_queued_data(struct tcp *conn)
 	if (subscribe) {
 		conn->send_data_retries = 0;
 		k_work_reschedule_for_queue(&tcp_work_q, &conn->send_data_timer,
-					    K_MSEC(tcp_rto));
+					    K_MSEC(TCP_RTO_MS));
 	}
  out:
 	return ret;
@@ -1232,7 +1255,7 @@ static void tcp_resend_data(struct k_work *work)
 		if (conn->in_close && conn->send_data_total == 0) {
 			NET_DBG("TCP connection in active close, "
 				"not disposing yet (waiting %dms)",
-				FIN_TIMEOUT_MS);
+				tcp_fin_timeout_ms);
 			k_work_reschedule_for_queue(&tcp_work_q,
 						    &conn->fin_timer,
 						    FIN_TIMEOUT);
@@ -1255,11 +1278,13 @@ static void tcp_resend_data(struct k_work *work)
 		NET_ERR("TCP failed to allocate buffer in retransmission");
 	}
 
-	/* Every retransmit, the retransmission timeout increases by a factor 2 */
-	exp_tcp_rto = tcp_rto << conn->send_data_retries;
+	exp_tcp_rto = TCP_RTO_MS;
 	/* The last retransmit does not need to wait that long */
-	if (conn->send_data_retries >= tcp_retries) {
-		exp_tcp_rto = tcp_rto;
+	if (conn->send_data_retries < tcp_retries) {
+		/* Every retransmit, the retransmission timeout increases by a factor 1.5 */
+		for (int i = 0; i < conn->send_data_retries; i++) {
+			exp_tcp_rto += exp_tcp_rto >> 1;
+		}
 	}
 
 	k_work_reschedule_for_queue(&tcp_work_q, &conn->send_data_timer,
@@ -1302,7 +1327,7 @@ static void tcp_fin_timeout(struct k_work *work)
 		return;
 	}
 
-	NET_DBG("Did not receive %s in %dms", "FIN", FIN_TIMEOUT_MS);
+	NET_DBG("Did not receive %s in %dms", "FIN", tcp_fin_timeout_ms);
 	NET_DBG("conn: %p %s", conn, tcp_conn_state(conn, NULL));
 
 	/* Extra unref from net_tcp_put() */
@@ -1318,9 +1343,11 @@ static void tcp_send_zwp(struct k_work *work)
 
 	(void)tcp_out_ext(conn, ACK, NULL, conn->seq - 1);
 
+	tcp_derive_rto(conn);
+
 	if (conn->send_win == 0) {
 		(void)k_work_reschedule_for_queue(
-			&tcp_work_q, &conn->persist_timer, K_MSEC(tcp_rto));
+			&tcp_work_q, &conn->persist_timer, K_MSEC(TCP_RTO_MS));
 	}
 
 	k_mutex_unlock(&conn->lock);
@@ -1644,6 +1671,7 @@ static struct tcp *tcp_conn_new(struct net_pkt *pkt)
 
 	conn = context->tcp;
 	conn->iface = pkt->iface;
+	tcp_derive_rto(conn);
 
 	net_context_set_family(conn->context, net_pkt_family(pkt));
 
@@ -1966,7 +1994,7 @@ static enum net_verdict tcp_in(struct tcp *conn, struct net_pkt *pkt)
 
 		if (conn->send_win == 0) {
 			(void)k_work_reschedule_for_queue(
-				&tcp_work_q, &conn->persist_timer, K_MSEC(tcp_rto));
+				&tcp_work_q, &conn->persist_timer, K_MSEC(TCP_RTO_MS));
 		} else {
 			(void)k_work_cancel_delayable(&conn->persist_timer);
 		}
@@ -2138,6 +2166,7 @@ static enum net_verdict tcp_in(struct tcp *conn, struct net_pkt *pkt)
 			k_work_cancel_delayable(&conn->send_data_timer);
 			if (conn->data_mode == TCP_DATA_MODE_RESEND) {
 				conn->unacked_len = 0;
+				tcp_derive_rto(conn);
 			}
 			conn->data_mode = TCP_DATA_MODE_SEND;
 
@@ -2325,12 +2354,12 @@ int net_tcp_put(struct net_context *context)
 			 */
 			k_work_reschedule_for_queue(&tcp_work_q,
 						    &conn->send_data_timer,
-						    K_MSEC(tcp_rto));
+						    K_MSEC(TCP_RTO_MS));
 		} else {
 			int ret;
 
 			NET_DBG("TCP connection in active close, not "
-				"disposing yet (waiting %dms)", FIN_TIMEOUT_MS);
+				"disposing yet (waiting %dms)", tcp_fin_timeout_ms);
 			k_work_reschedule_for_queue(&tcp_work_q,
 						    &conn->fin_timer,
 						    FIN_TIMEOUT);
@@ -2542,6 +2571,7 @@ int net_tcp_connect(struct net_context *context,
 
 	conn = context->tcp;
 	conn->iface = net_context_get_iface(context);
+	tcp_derive_rto(conn);
 
 	switch (net_context_get_family(context)) {
 		const struct in_addr *ip4;
@@ -3162,6 +3192,8 @@ struct k_sem *net_tcp_tx_sem_get(struct net_context *context)
 
 void net_tcp_init(void)
 {
+	int i;
+	int rto;
 #if defined(CONFIG_NET_TEST_PROTOCOL)
 	/* Register inputs for TTCN-3 based TCP sanity check */
 	test_cb_register(AF_INET,  IPPROTO_TCP, 4242, 4242, tcp_input);
@@ -3184,6 +3216,21 @@ void net_tcp_init(void)
 			   K_KERNEL_STACK_SIZEOF(work_q_stack), THREAD_PRIORITY,
 			   NULL);
 
+	/* Compute the largest possible retransmission timeout */
+	tcp_fin_timeout_ms = 0;
+	rto = tcp_rto;
+	for (i = 0; i < tcp_retries; i++) {
+		tcp_fin_timeout_ms += rto;
+		rto += rto >> 1;
+	}
+	/* At the last timeout cicle */
+	tcp_fin_timeout_ms += tcp_rto;
+
+	/* When CONFIG_NET_TCP_RANDOMIZED_RTO is active in can be worse case 1.5 times larger */
+	if (IS_ENABLED(CONFIG_NET_TCP_RANDOMIZED_RTO)) {
+		tcp_fin_timeout_ms += tcp_fin_timeout_ms >> 1;
+	}
+
 	k_thread_name_set(&tcp_work_q.thread, "tcp_work");
 	NET_DBG("Workq started. Thread ID: %p", &tcp_work_q.thread);
 }

subsys/net/ip/tcp_private.h

@@ -267,6 +267,9 @@ struct tcp { /* TCP connection */
 	uint16_t recv_win_max;
 	uint16_t recv_win;
 	uint16_t send_win;
+#ifdef CONFIG_NET_TCP_RANDOMIZED_RTO
+	uint16_t rto;
+#endif
 	uint8_t send_data_retries;
 	bool in_retransmission : 1;
 	bool in_connect : 1;

tests/net/socket/poll/prj.conf

@@ -22,6 +22,8 @@ CONFIG_NET_CONFIG_NEED_IPV6=y
 CONFIG_MAIN_STACK_SIZE=2048
 CONFIG_ZTEST_STACK_SIZE=1280
 
+CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT=100
+
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
 

tests/net/socket/select/prj.conf

@@ -25,6 +25,8 @@ CONFIG_MAIN_STACK_SIZE=2048
 CONFIG_ZTEST=y
 CONFIG_ZTEST_NEW_API=y
 
+CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT=100
+
 # User mode requirements
 CONFIG_TEST_USERSPACE=y
 CONFIG_HEAP_MEM_POOL_SIZE=128

tests/net/socket/tcp/prj.conf

@@ -40,7 +40,7 @@ CONFIG_NET_PKT_TX_COUNT=8
 
 # Reduce the retry count, so the close always finishes within a second
 CONFIG_NET_TCP_RETRY_COUNT=3
-CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT=200
+CONFIG_NET_TCP_INIT_RETRANSMISSION_TIMEOUT=120
 
 CONFIG_ZTEST=y
 CONFIG_ZTEST_STACK_SIZE=2048

tests/net/socket/tcp/src/main.c

@@ -21,7 +21,7 @@ LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
 
 #define MAX_CONNS 5
 
-#define TCP_TEARDOWN_TIMEOUT K_SECONDS(2)
+#define TCP_TEARDOWN_TIMEOUT K_SECONDS(3)
 #define THREAD_SLEEP 50 /* ms */
 
 static void test_bind(int sock, struct sockaddr *addr, socklen_t addrlen)

tests/net/socket/tcp/testcase.yaml

@@ -11,3 +11,4 @@ tests:
   net.socket.tcp.preempt:
     extra_configs:
       - CONFIG_NET_TC_THREAD_PREEMPTIVE=y
+      - CONFIG_NET_TCP_RANDOMIZED_RTO=n

tests/net/tcp/src/main.c

@@ -952,7 +952,7 @@ static void test_client_syn_resend(void)
 	ret = net_context_connect(ctx, (struct sockaddr *)&peer_addr_s,
 				  sizeof(struct sockaddr_in),
 				  NULL,
-				  K_MSEC(300), NULL);
+				  K_MSEC(300 + 50), NULL);
 
 	zassert_true(ret < 0, "Connect on no response from peer");