xref: /openbmc/linux/net/rxrpc/rtt.c (revision 48cc39c3)
1 // SPDX-License-Identifier: GPL-2.0
2 /* RTT/RTO calculation.
3  *
4  * Adapted from TCP for AF_RXRPC by David Howells (dhowells@redhat.com)
5  *
6  * https://tools.ietf.org/html/rfc6298
7  * https://tools.ietf.org/html/rfc1122#section-4.2.3.1
8  * http://ccr.sigcomm.org/archive/1995/jan95/ccr-9501-partridge87.pdf
9  */
10 
11 #include <linux/net.h>
12 #include "ar-internal.h"
13 
14 #define RXRPC_RTO_MAX	((unsigned)(120 * HZ))
15 #define RXRPC_TIMEOUT_INIT ((unsigned)(1*HZ))	/* RFC6298 2.1 initial RTO value	*/
16 #define rxrpc_jiffies32 ((u32)jiffies)		/* As rxrpc_jiffies32 */
17 
18 static u32 rxrpc_rto_min_us(struct rxrpc_peer *peer)
19 {
20 	return 200;
21 }
22 
23 static u32 __rxrpc_set_rto(const struct rxrpc_peer *peer)
24 {
25 	return _usecs_to_jiffies((peer->srtt_us >> 3) + peer->rttvar_us);
26 }
27 
28 static u32 rxrpc_bound_rto(u32 rto)
29 {
30 	return min(rto, RXRPC_RTO_MAX);
31 }
32 
33 /*
34  * Called to compute a smoothed rtt estimate. The data fed to this
35  * routine either comes from timestamps, or from segments that were
36  * known _not_ to have been retransmitted [see Karn/Partridge
37  * Proceedings SIGCOMM 87]. The algorithm is from the SIGCOMM 88
38  * piece by Van Jacobson.
39  * NOTE: the next three routines used to be one big routine.
40  * To save cycles in the RFC 1323 implementation it was better to break
41  * it up into three procedures. -- erics
42  */
43 static void rxrpc_rtt_estimator(struct rxrpc_peer *peer, long sample_rtt_us)
44 {
45 	long m = sample_rtt_us; /* RTT */
46 	u32 srtt = peer->srtt_us;
47 
48 	/*	The following amusing code comes from Jacobson's
49 	 *	article in SIGCOMM '88.  Note that rtt and mdev
50 	 *	are scaled versions of rtt and mean deviation.
51 	 *	This is designed to be as fast as possible
52 	 *	m stands for "measurement".
53 	 *
54 	 *	On a 1990 paper the rto value is changed to:
55 	 *	RTO = rtt + 4 * mdev
56 	 *
57 	 * Funny. This algorithm seems to be very broken.
58 	 * These formulae increase RTO, when it should be decreased, increase
59 	 * too slowly, when it should be increased quickly, decrease too quickly
60 	 * etc. I guess in BSD RTO takes ONE value, so that it is absolutely
61 	 * does not matter how to _calculate_ it. Seems, it was trap
62 	 * that VJ failed to avoid. 8)
63 	 */
64 	if (srtt != 0) {
65 		m -= (srtt >> 3);	/* m is now error in rtt est */
66 		srtt += m;		/* rtt = 7/8 rtt + 1/8 new */
67 		if (m < 0) {
68 			m = -m;		/* m is now abs(error) */
69 			m -= (peer->mdev_us >> 2);   /* similar update on mdev */
70 			/* This is similar to one of Eifel findings.
71 			 * Eifel blocks mdev updates when rtt decreases.
72 			 * This solution is a bit different: we use finer gain
73 			 * for mdev in this case (alpha*beta).
74 			 * Like Eifel it also prevents growth of rto,
75 			 * but also it limits too fast rto decreases,
76 			 * happening in pure Eifel.
77 			 */
78 			if (m > 0)
79 				m >>= 3;
80 		} else {
81 			m -= (peer->mdev_us >> 2);   /* similar update on mdev */
82 		}
83 
84 		peer->mdev_us += m;		/* mdev = 3/4 mdev + 1/4 new */
85 		if (peer->mdev_us > peer->mdev_max_us) {
86 			peer->mdev_max_us = peer->mdev_us;
87 			if (peer->mdev_max_us > peer->rttvar_us)
88 				peer->rttvar_us = peer->mdev_max_us;
89 		}
90 	} else {
91 		/* no previous measure. */
92 		srtt = m << 3;		/* take the measured time to be rtt */
93 		peer->mdev_us = m << 1;	/* make sure rto = 3*rtt */
94 		peer->rttvar_us = max(peer->mdev_us, rxrpc_rto_min_us(peer));
95 		peer->mdev_max_us = peer->rttvar_us;
96 	}
97 
98 	peer->srtt_us = max(1U, srtt);
99 }
100 
101 /*
102  * Calculate rto without backoff.  This is the second half of Van Jacobson's
103  * routine referred to above.
104  */
105 static void rxrpc_set_rto(struct rxrpc_peer *peer)
106 {
107 	u32 rto;
108 
109 	/* 1. If rtt variance happened to be less 50msec, it is hallucination.
110 	 *    It cannot be less due to utterly erratic ACK generation made
111 	 *    at least by solaris and freebsd. "Erratic ACKs" has _nothing_
112 	 *    to do with delayed acks, because at cwnd>2 true delack timeout
113 	 *    is invisible. Actually, Linux-2.4 also generates erratic
114 	 *    ACKs in some circumstances.
115 	 */
116 	rto = __rxrpc_set_rto(peer);
117 
118 	/* 2. Fixups made earlier cannot be right.
119 	 *    If we do not estimate RTO correctly without them,
120 	 *    all the algo is pure shit and should be replaced
121 	 *    with correct one. It is exactly, which we pretend to do.
122 	 */
123 
124 	/* NOTE: clamping at RXRPC_RTO_MIN is not required, current algo
125 	 * guarantees that rto is higher.
126 	 */
127 	peer->rto_j = rxrpc_bound_rto(rto);
128 }
129 
130 static void rxrpc_ack_update_rtt(struct rxrpc_peer *peer, long rtt_us)
131 {
132 	if (rtt_us < 0)
133 		return;
134 
135 	//rxrpc_update_rtt_min(peer, rtt_us);
136 	rxrpc_rtt_estimator(peer, rtt_us);
137 	rxrpc_set_rto(peer);
138 
139 	/* RFC6298: only reset backoff on valid RTT measurement. */
140 	peer->backoff = 0;
141 }
142 
143 /*
144  * Add RTT information to cache.  This is called in softirq mode and has
145  * exclusive access to the peer RTT data.
146  */
147 void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
148 			int rtt_slot,
149 			rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
150 			ktime_t send_time, ktime_t resp_time)
151 {
152 	struct rxrpc_peer *peer = call->peer;
153 	s64 rtt_us;
154 
155 	rtt_us = ktime_to_us(ktime_sub(resp_time, send_time));
156 	if (rtt_us < 0)
157 		return;
158 
159 	spin_lock(&peer->rtt_input_lock);
160 	rxrpc_ack_update_rtt(peer, rtt_us);
161 	if (peer->rtt_count < 3)
162 		peer->rtt_count++;
163 	spin_unlock(&peer->rtt_input_lock);
164 
165 	trace_rxrpc_rtt_rx(call, why, rtt_slot, send_serial, resp_serial,
166 			   peer->srtt_us >> 3, peer->rto_j);
167 }
168 
169 /*
170  * Get the retransmission timeout to set in jiffies, backing it off each time
171  * we retransmit.
172  */
173 unsigned long rxrpc_get_rto_backoff(struct rxrpc_peer *peer, bool retrans)
174 {
175 	u64 timo_j;
176 	u8 backoff = READ_ONCE(peer->backoff);
177 
178 	timo_j = peer->rto_j;
179 	timo_j <<= backoff;
180 	if (retrans && timo_j * 2 <= RXRPC_RTO_MAX)
181 		WRITE_ONCE(peer->backoff, backoff + 1);
182 
183 	if (timo_j < 1)
184 		timo_j = 1;
185 
186 	return timo_j;
187 }
188 
189 void rxrpc_peer_init_rtt(struct rxrpc_peer *peer)
190 {
191 	peer->rto_j	= RXRPC_TIMEOUT_INIT;
192 	peer->mdev_us	= jiffies_to_usecs(RXRPC_TIMEOUT_INIT);
193 	peer->backoff	= 0;
194 	//minmax_reset(&peer->rtt_min, rxrpc_jiffies32, ~0U);
195 }
196