Commit f5b01ded authored by Yuchung Cheng's avatar Yuchung Cheng Committed by Zhengchao Shao
Browse files

net: tcp better handling of reordering then loss cases 

stable inclusion
from stable-v4.19.318
commit 550968385e2f0df8e29c6431ab2dc0961499acb0
category: bugfix
bugzilla: https://gitee.com/openeuler/kernel/issues/IAMPH5

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=550968385e2f0df8e29c6431ab2dc0961499acb0

---------------------------

[ Upstream commit a29cb691 ]

This patch aims to improve the situation when reordering and loss are
ocurring in the same flight of packets.

Previously the reordering would first induce a spurious recovery, then
the subsequent ACK may undo the cwnd (based on the timestamps e.g.).
However the current loss recovery does not proceed to invoke
RACK to install a reordering timer. If some packets are also lost, this
may lead to a long RTO-based recovery. An example is
https://groups.google.com/g/bbr-dev/c/OFHADvJbTEI



The solution is to after reverting the recovery, always invoke RACK
to either mount the RACK timer to fast retransmit after the reordering
window, or restarts the recovery if new loss is identified. Hence
it is possible the sender may go from Recovery to Disorder/Open to
Recovery again in one ACK.

Reported-by: default avatarmingkun bian <bianmingkun@gmail.com>
Signed-off-by: default avatarYuchung Cheng <ycheng@google.com>
Signed-off-by: default avatarNeal Cardwell <ncardwell@google.com>
Signed-off-by: default avatarEric Dumazet <edumazet@google.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
Stable-dep-of: a6458ab7fd4f ("UPSTREAM: tcp: fix DSACK undo in fast recovery to call tcp_try_to_open()")
Signed-off-by: default avatarSasha Levin <sashal@kernel.org>
Signed-off-by: default avatarZhengchao Shao <shaozhengchao@huawei.com>
parent 7a998933

net/ipv4/tcp_input.c

+26 −19
Original line number Diff line number Diff line
@@ -2723,8 +2723,17 @@ static void tcp_process_loss(struct sock *sk, int flag, int num_dupack, 
	*rexmit = REXMIT_LOST;

}



static bool tcp_force_fast_retransmit(struct sock *sk)

{

	struct tcp_sock *tp = tcp_sk(sk);



	return after(tcp_highest_sack_seq(tp),

		     tp->snd_una + tp->reordering * tp->mss_cache);

}



/* Undo during fast recovery after partial ACK. */

static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una)

static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una,

				 bool *do_lost)

{

	struct tcp_sock *tp = tcp_sk(sk);
@@ -2749,7 +2758,9 @@ static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una) 
		tcp_undo_cwnd_reduction(sk, true);

		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);

		tcp_try_keep_open(sk);

		return true;

	} else {

		/* Partial ACK arrived. Force fast retransmit. */

		*do_lost = tcp_force_fast_retransmit(sk);

	}

	return false;

}
@@ -2773,14 +2784,6 @@ static void tcp_identify_packet_loss(struct sock *sk, int *ack_flag) 
	}

}



static bool tcp_force_fast_retransmit(struct sock *sk)

{

	struct tcp_sock *tp = tcp_sk(sk);



	return after(tcp_highest_sack_seq(tp),

		     tp->snd_una + tp->reordering * tp->mss_cache);

}



/* Process an event, which can update packets-in-flight not trivially.

 * Main goal of this function is to calculate new estimate for left_out,

 * taking into account both packets sitting in receiver's buffer and
@@ -2850,17 +2853,21 @@ static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una, 
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {

			if (tcp_is_reno(tp))

				tcp_add_reno_sack(sk, num_dupack, ece_ack);

		} else {

			if (tcp_try_undo_partial(sk, prior_snd_una))

		} else if (tcp_try_undo_partial(sk, prior_snd_una, &do_lost))

			return;

			/* Partial ACK arrived. Force fast retransmit. */

			do_lost = tcp_force_fast_retransmit(sk);

		}

		if (tcp_try_undo_dsack(sk)) {



		if (tcp_try_undo_dsack(sk))

			tcp_try_keep_open(sk);



		tcp_identify_packet_loss(sk, ack_flag);

		if (icsk->icsk_ca_state != TCP_CA_Recovery) {

			if (!tcp_time_to_recover(sk, flag))

				return;

			/* Undo reverts the recovery state. If loss is evident,

			 * starts a new recovery (e.g. reordering then loss);

			 */

			tcp_enter_recovery(sk, ece_ack);

		}

		tcp_identify_packet_loss(sk, ack_flag);

		break;

	case TCP_CA_Loss:

		tcp_process_loss(sk, flag, num_dupack, rexmit);