1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * H-TCP congestion control. The algorithm is detailed in: 4 * R.N.Shorten, D.J.Leith: 5 * "H-TCP: TCP for high-speed and long-distance networks" 6 * Proc. PFLDnet, Argonne, 2004. 7 * https://www.hamilton.ie/net/htcp3.pdf 8 */ 9 10 #include <linux/mm.h> 11 #include <linux/module.h> 12 #include <net/tcp.h> 13 14 #define ALPHA_BASE (1<<7) /* 1.0 with shift << 7 */ 15 #define BETA_MIN (1<<6) /* 0.5 with shift << 7 */ 16 #define BETA_MAX 102 /* 0.8 with shift << 7 */ 17 18 static int use_rtt_scaling __read_mostly = 1; 19 module_param(use_rtt_scaling, int, 0644); 20 MODULE_PARM_DESC(use_rtt_scaling, "turn on/off RTT scaling"); 21 22 static int use_bandwidth_switch __read_mostly = 1; 23 module_param(use_bandwidth_switch, int, 0644); 24 MODULE_PARM_DESC(use_bandwidth_switch, "turn on/off bandwidth switcher"); 25 26 struct htcp { 27 u32 alpha; /* Fixed point arith, << 7 */ 28 u8 beta; /* Fixed point arith, << 7 */ 29 u8 modeswitch; /* Delay modeswitch 30 until we had at least one congestion event */ 31 u16 pkts_acked; 32 u32 packetcount; 33 u32 minRTT; 34 u32 maxRTT; 35 u32 last_cong; /* Time since last congestion event end */ 36 u32 undo_last_cong; 37 38 u32 undo_maxRTT; 39 u32 undo_old_maxB; 40 41 /* Bandwidth estimation */ 42 u32 minB; 43 u32 maxB; 44 u32 old_maxB; 45 u32 Bi; 46 u32 lasttime; 47 }; 48 49 static inline u32 htcp_cong_time(const struct htcp *ca) 50 { 51 return jiffies - ca->last_cong; 52 } 53 54 static inline u32 htcp_ccount(const struct htcp *ca) 55 { 56 return htcp_cong_time(ca) / ca->minRTT; 57 } 58 59 static inline void htcp_reset(struct htcp *ca) 60 { 61 ca->undo_last_cong = ca->last_cong; 62 ca->undo_maxRTT = ca->maxRTT; 63 ca->undo_old_maxB = ca->old_maxB; 64 65 ca->last_cong = jiffies; 66 } 67 68 static u32 htcp_cwnd_undo(struct sock *sk) 69 { 70 struct htcp *ca = inet_csk_ca(sk); 71 72 if (ca->undo_last_cong) { 73 ca->last_cong = ca->undo_last_cong; 74 ca->maxRTT = ca->undo_maxRTT; 75 ca->old_maxB = ca->undo_old_maxB; 76 ca->undo_last_cong = 0; 77 } 78 79 return tcp_reno_undo_cwnd(sk); 80 } 81 82 static inline void measure_rtt(struct sock *sk, u32 srtt) 83 { 84 const struct inet_connection_sock *icsk = inet_csk(sk); 85 struct htcp *ca = inet_csk_ca(sk); 86 87 /* keep track of minimum RTT seen so far, minRTT is zero at first */ 88 if (ca->minRTT > srtt || !ca->minRTT) 89 ca->minRTT = srtt; 90 91 /* max RTT */ 92 if (icsk->icsk_ca_state == TCP_CA_Open) { 93 if (ca->maxRTT < ca->minRTT) 94 ca->maxRTT = ca->minRTT; 95 if (ca->maxRTT < srtt && 96 srtt <= ca->maxRTT + msecs_to_jiffies(20)) 97 ca->maxRTT = srtt; 98 } 99 } 100 101 static void measure_achieved_throughput(struct sock *sk, 102 const struct ack_sample *sample) 103 { 104 const struct inet_connection_sock *icsk = inet_csk(sk); 105 const struct tcp_sock *tp = tcp_sk(sk); 106 struct htcp *ca = inet_csk_ca(sk); 107 u32 now = tcp_jiffies32; 108 109 if (icsk->icsk_ca_state == TCP_CA_Open) 110 ca->pkts_acked = sample->pkts_acked; 111 112 if (sample->rtt_us > 0) 113 measure_rtt(sk, usecs_to_jiffies(sample->rtt_us)); 114 115 if (!use_bandwidth_switch) 116 return; 117 118 /* achieved throughput calculations */ 119 if (!((1 << icsk->icsk_ca_state) & (TCPF_CA_Open | TCPF_CA_Disorder))) { 120 ca->packetcount = 0; 121 ca->lasttime = now; 122 return; 123 } 124 125 ca->packetcount += sample->pkts_acked; 126 127 if (ca->packetcount >= tcp_snd_cwnd(tp) - (ca->alpha >> 7 ? : 1) && 128 now - ca->lasttime >= ca->minRTT && 129 ca->minRTT > 0) { 130 __u32 cur_Bi = ca->packetcount * HZ / (now - ca->lasttime); 131 132 if (htcp_ccount(ca) <= 3) { 133 /* just after backoff */ 134 ca->minB = ca->maxB = ca->Bi = cur_Bi; 135 } else { 136 ca->Bi = (3 * ca->Bi + cur_Bi) / 4; 137 if (ca->Bi > ca->maxB) 138 ca->maxB = ca->Bi; 139 if (ca->minB > ca->maxB) 140 ca->minB = ca->maxB; 141 } 142 ca->packetcount = 0; 143 ca->lasttime = now; 144 } 145 } 146 147 static inline void htcp_beta_update(struct htcp *ca, u32 minRTT, u32 maxRTT) 148 { 149 if (use_bandwidth_switch) { 150 u32 maxB = ca->maxB; 151 u32 old_maxB = ca->old_maxB; 152 153 ca->old_maxB = ca->maxB; 154 if (!between(5 * maxB, 4 * old_maxB, 6 * old_maxB)) { 155 ca->beta = BETA_MIN; 156 ca->modeswitch = 0; 157 return; 158 } 159 } 160 161 if (ca->modeswitch && minRTT > msecs_to_jiffies(10) && maxRTT) { 162 ca->beta = (minRTT << 7) / maxRTT; 163 if (ca->beta < BETA_MIN) 164 ca->beta = BETA_MIN; 165 else if (ca->beta > BETA_MAX) 166 ca->beta = BETA_MAX; 167 } else { 168 ca->beta = BETA_MIN; 169 ca->modeswitch = 1; 170 } 171 } 172 173 static inline void htcp_alpha_update(struct htcp *ca) 174 { 175 u32 minRTT = ca->minRTT; 176 u32 factor = 1; 177 u32 diff = htcp_cong_time(ca); 178 179 if (diff > HZ) { 180 diff -= HZ; 181 factor = 1 + (10 * diff + ((diff / 2) * (diff / 2) / HZ)) / HZ; 182 } 183 184 if (use_rtt_scaling && minRTT) { 185 u32 scale = (HZ << 3) / (10 * minRTT); 186 187 /* clamping ratio to interval [0.5,10]<<3 */ 188 scale = min(max(scale, 1U << 2), 10U << 3); 189 factor = (factor << 3) / scale; 190 if (!factor) 191 factor = 1; 192 } 193 194 ca->alpha = 2 * factor * ((1 << 7) - ca->beta); 195 if (!ca->alpha) 196 ca->alpha = ALPHA_BASE; 197 } 198 199 /* 200 * After we have the rtt data to calculate beta, we'd still prefer to wait one 201 * rtt before we adjust our beta to ensure we are working from a consistent 202 * data. 203 * 204 * This function should be called when we hit a congestion event since only at 205 * that point do we really have a real sense of maxRTT (the queues en route 206 * were getting just too full now). 207 */ 208 static void htcp_param_update(struct sock *sk) 209 { 210 struct htcp *ca = inet_csk_ca(sk); 211 u32 minRTT = ca->minRTT; 212 u32 maxRTT = ca->maxRTT; 213 214 htcp_beta_update(ca, minRTT, maxRTT); 215 htcp_alpha_update(ca); 216 217 /* add slowly fading memory for maxRTT to accommodate routing changes */ 218 if (minRTT > 0 && maxRTT > minRTT) 219 ca->maxRTT = minRTT + ((maxRTT - minRTT) * 95) / 100; 220 } 221 222 static u32 htcp_recalc_ssthresh(struct sock *sk) 223 { 224 const struct tcp_sock *tp = tcp_sk(sk); 225 const struct htcp *ca = inet_csk_ca(sk); 226 227 htcp_param_update(sk); 228 return max((tcp_snd_cwnd(tp) * ca->beta) >> 7, 2U); 229 } 230 231 static void htcp_cong_avoid(struct sock *sk, u32 ack, u32 acked) 232 { 233 struct tcp_sock *tp = tcp_sk(sk); 234 struct htcp *ca = inet_csk_ca(sk); 235 236 if (!tcp_is_cwnd_limited(sk)) 237 return; 238 239 if (tcp_in_slow_start(tp)) 240 tcp_slow_start(tp, acked); 241 else { 242 /* In dangerous area, increase slowly. 243 * In theory this is tp->snd_cwnd += alpha / tp->snd_cwnd 244 */ 245 if ((tp->snd_cwnd_cnt * ca->alpha)>>7 >= tcp_snd_cwnd(tp)) { 246 if (tcp_snd_cwnd(tp) < tp->snd_cwnd_clamp) 247 tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) + 1); 248 tp->snd_cwnd_cnt = 0; 249 htcp_alpha_update(ca); 250 } else 251 tp->snd_cwnd_cnt += ca->pkts_acked; 252 253 ca->pkts_acked = 1; 254 } 255 } 256 257 static void htcp_init(struct sock *sk) 258 { 259 struct htcp *ca = inet_csk_ca(sk); 260 261 memset(ca, 0, sizeof(struct htcp)); 262 ca->alpha = ALPHA_BASE; 263 ca->beta = BETA_MIN; 264 ca->pkts_acked = 1; 265 ca->last_cong = jiffies; 266 } 267 268 static void htcp_state(struct sock *sk, u8 new_state) 269 { 270 switch (new_state) { 271 case TCP_CA_Open: 272 { 273 struct htcp *ca = inet_csk_ca(sk); 274 275 if (ca->undo_last_cong) { 276 ca->last_cong = jiffies; 277 ca->undo_last_cong = 0; 278 } 279 } 280 break; 281 case TCP_CA_CWR: 282 case TCP_CA_Recovery: 283 case TCP_CA_Loss: 284 htcp_reset(inet_csk_ca(sk)); 285 break; 286 } 287 } 288 289 static struct tcp_congestion_ops htcp __read_mostly = { 290 .init = htcp_init, 291 .ssthresh = htcp_recalc_ssthresh, 292 .cong_avoid = htcp_cong_avoid, 293 .set_state = htcp_state, 294 .undo_cwnd = htcp_cwnd_undo, 295 .pkts_acked = measure_achieved_throughput, 296 .owner = THIS_MODULE, 297 .name = "htcp", 298 }; 299 300 static int __init htcp_register(void) 301 { 302 BUILD_BUG_ON(sizeof(struct htcp) > ICSK_CA_PRIV_SIZE); 303 BUILD_BUG_ON(BETA_MIN >= BETA_MAX); 304 return tcp_register_congestion_control(&htcp); 305 } 306 307 static void __exit htcp_unregister(void) 308 { 309 tcp_unregister_congestion_control(&htcp); 310 } 311 312 module_init(htcp_register); 313 module_exit(htcp_unregister); 314 315 MODULE_AUTHOR("Baruch Even"); 316 MODULE_LICENSE("GPL"); 317 MODULE_DESCRIPTION("H-TCP"); 318