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