Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 1 | /* |
| 2 | * TCP Vegas congestion control |
| 3 | * |
| 4 | * This is based on the congestion detection/avoidance scheme described in |
| 5 | * Lawrence S. Brakmo and Larry L. Peterson. |
| 6 | * "TCP Vegas: End to end congestion avoidance on a global internet." |
| 7 | * IEEE Journal on Selected Areas in Communication, 13(8):1465--1480, |
| 8 | * October 1995. Available from: |
| 9 | * ftp://ftp.cs.arizona.edu/xkernel/Papers/jsac.ps |
| 10 | * |
| 11 | * See http://www.cs.arizona.edu/xkernel/ for their implementation. |
| 12 | * The main aspects that distinguish this implementation from the |
| 13 | * Arizona Vegas implementation are: |
| 14 | * o We do not change the loss detection or recovery mechanisms of |
| 15 | * Linux in any way. Linux already recovers from losses quite well, |
| 16 | * using fine-grained timers, NewReno, and FACK. |
| 17 | * o To avoid the performance penalty imposed by increasing cwnd |
| 18 | * only every-other RTT during slow start, we increase during |
| 19 | * every RTT during slow start, just like Reno. |
| 20 | * o Largely to allow continuous cwnd growth during slow start, |
| 21 | * we use the rate at which ACKs come back as the "actual" |
| 22 | * rate, rather than the rate at which data is sent. |
| 23 | * o To speed convergence to the right rate, we set the cwnd |
| 24 | * to achieve the right ("actual") rate when we exit slow start. |
| 25 | * o To filter out the noise caused by delayed ACKs, we use the |
| 26 | * minimum RTT sample observed during the last RTT to calculate |
| 27 | * the actual rate. |
| 28 | * o When the sender re-starts from idle, it waits until it has |
| 29 | * received ACKs for an entire flight of new data before making |
| 30 | * a cwnd adjustment decision. The original Vegas implementation |
| 31 | * assumed senders never went idle. |
| 32 | */ |
| 33 | |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 34 | #include <linux/mm.h> |
| 35 | #include <linux/module.h> |
| 36 | #include <linux/skbuff.h> |
Arnaldo Carvalho de Melo | a8c2190 | 2005-08-12 12:56:38 -0300 | [diff] [blame] | 37 | #include <linux/inet_diag.h> |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 38 | |
| 39 | #include <net/tcp.h> |
| 40 | |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 41 | #include "tcp_vegas.h" |
| 42 | |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 43 | static int alpha = 2; |
| 44 | static int beta = 4; |
| 45 | static int gamma = 1; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 46 | |
| 47 | module_param(alpha, int, 0644); |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 48 | MODULE_PARM_DESC(alpha, "lower bound of packets in network"); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 49 | module_param(beta, int, 0644); |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 50 | MODULE_PARM_DESC(beta, "upper bound of packets in network"); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 51 | module_param(gamma, int, 0644); |
| 52 | MODULE_PARM_DESC(gamma, "limit on increase (scale by 2)"); |
| 53 | |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 54 | /* There are several situations when we must "re-start" Vegas: |
| 55 | * |
| 56 | * o when a connection is established |
| 57 | * o after an RTO |
| 58 | * o after fast recovery |
| 59 | * o when we send a packet and there is no outstanding |
| 60 | * unacknowledged data (restarting an idle connection) |
| 61 | * |
| 62 | * In these circumstances we cannot do a Vegas calculation at the |
| 63 | * end of the first RTT, because any calculation we do is using |
| 64 | * stale info -- both the saved cwnd and congestion feedback are |
| 65 | * stale. |
| 66 | * |
| 67 | * Instead we must wait until the completion of an RTT during |
| 68 | * which we actually receive ACKs. |
| 69 | */ |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 70 | static void vegas_enable(struct sock *sk) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 71 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 72 | const struct tcp_sock *tp = tcp_sk(sk); |
| 73 | struct vegas *vegas = inet_csk_ca(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 74 | |
| 75 | /* Begin taking Vegas samples next time we send something. */ |
| 76 | vegas->doing_vegas_now = 1; |
| 77 | |
| 78 | /* Set the beginning of the next send window. */ |
| 79 | vegas->beg_snd_nxt = tp->snd_nxt; |
| 80 | |
| 81 | vegas->cntRTT = 0; |
| 82 | vegas->minRTT = 0x7fffffff; |
| 83 | } |
| 84 | |
| 85 | /* Stop taking Vegas samples for now. */ |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 86 | static inline void vegas_disable(struct sock *sk) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 87 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 88 | struct vegas *vegas = inet_csk_ca(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 89 | |
| 90 | vegas->doing_vegas_now = 0; |
| 91 | } |
| 92 | |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 93 | void tcp_vegas_init(struct sock *sk) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 94 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 95 | struct vegas *vegas = inet_csk_ca(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 96 | |
| 97 | vegas->baseRTT = 0x7fffffff; |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 98 | vegas_enable(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 99 | } |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 100 | EXPORT_SYMBOL_GPL(tcp_vegas_init); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 101 | |
| 102 | /* Do RTT sampling needed for Vegas. |
| 103 | * Basically we: |
| 104 | * o min-filter RTT samples from within an RTT to get the current |
| 105 | * propagation delay + queuing delay (we are min-filtering to try to |
| 106 | * avoid the effects of delayed ACKs) |
| 107 | * o min-filter RTT samples from a much longer window (forever for now) |
| 108 | * to find the propagation delay (baseRTT) |
| 109 | */ |
Stephen Hemminger | 30cfd0b | 2007-07-25 23:49:34 -0700 | [diff] [blame] | 110 | void tcp_vegas_pkts_acked(struct sock *sk, u32 cnt, s32 rtt_us) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 111 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 112 | struct vegas *vegas = inet_csk_ca(sk); |
Stephen Hemminger | 164891a | 2007-04-23 22:26:16 -0700 | [diff] [blame] | 113 | u32 vrtt; |
| 114 | |
Stephen Hemminger | 30cfd0b | 2007-07-25 23:49:34 -0700 | [diff] [blame] | 115 | if (rtt_us < 0) |
Ilpo Järvinen | b9ce204 | 2007-06-15 15:08:43 -0700 | [diff] [blame] | 116 | return; |
| 117 | |
Stephen Hemminger | 164891a | 2007-04-23 22:26:16 -0700 | [diff] [blame] | 118 | /* Never allow zero rtt or baseRTT */ |
Stephen Hemminger | 30cfd0b | 2007-07-25 23:49:34 -0700 | [diff] [blame] | 119 | vrtt = rtt_us + 1; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 120 | |
| 121 | /* Filter to find propagation delay: */ |
| 122 | if (vrtt < vegas->baseRTT) |
| 123 | vegas->baseRTT = vrtt; |
| 124 | |
| 125 | /* Find the min RTT during the last RTT to find |
| 126 | * the current prop. delay + queuing delay: |
| 127 | */ |
| 128 | vegas->minRTT = min(vegas->minRTT, vrtt); |
| 129 | vegas->cntRTT++; |
| 130 | } |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 131 | EXPORT_SYMBOL_GPL(tcp_vegas_pkts_acked); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 132 | |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 133 | void tcp_vegas_state(struct sock *sk, u8 ca_state) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 134 | { |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 135 | if (ca_state == TCP_CA_Open) |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 136 | vegas_enable(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 137 | else |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 138 | vegas_disable(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 139 | } |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 140 | EXPORT_SYMBOL_GPL(tcp_vegas_state); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 141 | |
| 142 | /* |
| 143 | * If the connection is idle and we are restarting, |
| 144 | * then we don't want to do any Vegas calculations |
| 145 | * until we get fresh RTT samples. So when we |
| 146 | * restart, we reset our Vegas state to a clean |
| 147 | * slate. After we get acks for this flight of |
| 148 | * packets, _then_ we can make Vegas calculations |
| 149 | * again. |
| 150 | */ |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 151 | void tcp_vegas_cwnd_event(struct sock *sk, enum tcp_ca_event event) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 152 | { |
| 153 | if (event == CA_EVENT_CWND_RESTART || |
| 154 | event == CA_EVENT_TX_START) |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 155 | tcp_vegas_init(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 156 | } |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 157 | EXPORT_SYMBOL_GPL(tcp_vegas_cwnd_event); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 158 | |
Doug Leith | c80a5cd | 2009-05-25 22:44:59 -0700 | [diff] [blame] | 159 | static inline u32 tcp_vegas_ssthresh(struct tcp_sock *tp) |
| 160 | { |
| 161 | return min(tp->snd_ssthresh, tp->snd_cwnd-1); |
| 162 | } |
| 163 | |
Eric Dumazet | 2490155 | 2014-05-02 21:18:05 -0700 | [diff] [blame] | 164 | static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 acked) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 165 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 166 | struct tcp_sock *tp = tcp_sk(sk); |
| 167 | struct vegas *vegas = inet_csk_ca(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 168 | |
Harvey Harrison | ab59859 | 2008-05-01 02:47:38 -0700 | [diff] [blame] | 169 | if (!vegas->doing_vegas_now) { |
Eric Dumazet | 2490155 | 2014-05-02 21:18:05 -0700 | [diff] [blame] | 170 | tcp_reno_cong_avoid(sk, ack, acked); |
Harvey Harrison | ab59859 | 2008-05-01 02:47:38 -0700 | [diff] [blame] | 171 | return; |
| 172 | } |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 173 | |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 174 | if (after(ack, vegas->beg_snd_nxt)) { |
| 175 | /* Do the Vegas once-per-RTT cwnd adjustment. */ |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 176 | |
| 177 | /* Save the extent of the current window so we can use this |
| 178 | * at the end of the next RTT. |
| 179 | */ |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 180 | vegas->beg_snd_nxt = tp->snd_nxt; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 181 | |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 182 | /* We do the Vegas calculations only if we got enough RTT |
| 183 | * samples that we can be reasonably sure that we got |
| 184 | * at least one RTT sample that wasn't from a delayed ACK. |
| 185 | * If we only had 2 samples total, |
| 186 | * then that means we're getting only 1 ACK per RTT, which |
| 187 | * means they're almost certainly delayed ACKs. |
| 188 | * If we have 3 samples, we should be OK. |
| 189 | */ |
| 190 | |
| 191 | if (vegas->cntRTT <= 2) { |
| 192 | /* We don't have enough RTT samples to do the Vegas |
| 193 | * calculation, so we'll behave like Reno. |
| 194 | */ |
Eric Dumazet | 2490155 | 2014-05-02 21:18:05 -0700 | [diff] [blame] | 195 | tcp_reno_cong_avoid(sk, ack, acked); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 196 | } else { |
Lachlan Andrew | 1591311 | 2008-04-30 01:04:03 -0700 | [diff] [blame] | 197 | u32 rtt, diff; |
| 198 | u64 target_cwnd; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 199 | |
| 200 | /* We have enough RTT samples, so, using the Vegas |
| 201 | * algorithm, we determine if we should increase or |
| 202 | * decrease cwnd, and by how much. |
| 203 | */ |
| 204 | |
| 205 | /* Pluck out the RTT we are using for the Vegas |
| 206 | * calculations. This is the min RTT seen during the |
| 207 | * last RTT. Taking the min filters out the effects |
| 208 | * of delayed ACKs, at the cost of noticing congestion |
| 209 | * a bit later. |
| 210 | */ |
| 211 | rtt = vegas->minRTT; |
| 212 | |
| 213 | /* Calculate the cwnd we should have, if we weren't |
| 214 | * going too fast. |
| 215 | * |
| 216 | * This is: |
| 217 | * (actual rate in segments) * baseRTT |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 218 | */ |
Christoph Paasch | 1f74e61 | 2014-07-29 13:40:57 +0200 | [diff] [blame] | 219 | target_cwnd = (u64)tp->snd_cwnd * vegas->baseRTT; |
| 220 | do_div(target_cwnd, rtt); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 221 | |
| 222 | /* Calculate the difference between the window we had, |
| 223 | * and the window we would like to have. This quantity |
| 224 | * is the "Diff" from the Arizona Vegas papers. |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 225 | */ |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 226 | diff = tp->snd_cwnd * (rtt-vegas->baseRTT) / vegas->baseRTT; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 227 | |
Yuchung Cheng | 071d508 | 2015-07-09 13:16:29 -0700 | [diff] [blame] | 228 | if (diff > gamma && tcp_in_slow_start(tp)) { |
Xiaoliang (David) Wei | c940587 | 2007-10-29 20:24:36 -0700 | [diff] [blame] | 229 | /* Going too fast. Time to slow down |
| 230 | * and switch to congestion avoidance. |
| 231 | */ |
Xiaoliang (David) Wei | c940587 | 2007-10-29 20:24:36 -0700 | [diff] [blame] | 232 | |
| 233 | /* Set cwnd to match the actual rate |
| 234 | * exactly: |
| 235 | * cwnd = (actual rate) * baseRTT |
| 236 | * Then we add 1 because the integer |
| 237 | * truncation robs us of full link |
| 238 | * utilization. |
| 239 | */ |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 240 | tp->snd_cwnd = min(tp->snd_cwnd, (u32)target_cwnd+1); |
Doug Leith | c80a5cd | 2009-05-25 22:44:59 -0700 | [diff] [blame] | 241 | tp->snd_ssthresh = tcp_vegas_ssthresh(tp); |
Xiaoliang (David) Wei | c940587 | 2007-10-29 20:24:36 -0700 | [diff] [blame] | 242 | |
Yuchung Cheng | 071d508 | 2015-07-09 13:16:29 -0700 | [diff] [blame] | 243 | } else if (tcp_in_slow_start(tp)) { |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 244 | /* Slow start. */ |
Yuchung Cheng | 9f9843a7 | 2013-10-31 11:07:31 -0700 | [diff] [blame] | 245 | tcp_slow_start(tp, acked); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 246 | } else { |
| 247 | /* Congestion avoidance. */ |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 248 | |
| 249 | /* Figure out where we would like cwnd |
| 250 | * to be. |
| 251 | */ |
| 252 | if (diff > beta) { |
| 253 | /* The old window was too fast, so |
| 254 | * we slow down. |
| 255 | */ |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 256 | tp->snd_cwnd--; |
Doug Leith | c80a5cd | 2009-05-25 22:44:59 -0700 | [diff] [blame] | 257 | tp->snd_ssthresh |
| 258 | = tcp_vegas_ssthresh(tp); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 259 | } else if (diff < alpha) { |
| 260 | /* We don't have enough extra packets |
| 261 | * in the network, so speed up. |
| 262 | */ |
Doug Leith | 8d3a564 | 2008-12-09 00:13:04 -0800 | [diff] [blame] | 263 | tp->snd_cwnd++; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 264 | } else { |
| 265 | /* Sending just as fast as we |
| 266 | * should be. |
| 267 | */ |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 268 | } |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 269 | } |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 270 | |
Stephen Hemminger | 7faffa1 | 2005-11-10 17:07:24 -0800 | [diff] [blame] | 271 | if (tp->snd_cwnd < 2) |
| 272 | tp->snd_cwnd = 2; |
| 273 | else if (tp->snd_cwnd > tp->snd_cwnd_clamp) |
| 274 | tp->snd_cwnd = tp->snd_cwnd_clamp; |
Doug Leith | a6af2d6 | 2008-12-04 17:17:18 -0800 | [diff] [blame] | 275 | |
| 276 | tp->snd_ssthresh = tcp_current_ssthresh(sk); |
Stephen Hemminger | 7faffa1 | 2005-11-10 17:07:24 -0800 | [diff] [blame] | 277 | } |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 278 | |
Thomas Young | 5b49561 | 2005-12-06 16:16:34 -0800 | [diff] [blame] | 279 | /* Wipe the slate clean for the next RTT. */ |
| 280 | vegas->cntRTT = 0; |
| 281 | vegas->minRTT = 0x7fffffff; |
| 282 | } |
Thomas Young | 74cb879 | 2006-01-04 13:59:32 -0800 | [diff] [blame] | 283 | /* Use normal slow start */ |
Yuchung Cheng | 071d508 | 2015-07-09 13:16:29 -0700 | [diff] [blame] | 284 | else if (tcp_in_slow_start(tp)) |
Yuchung Cheng | 9f9843a7 | 2013-10-31 11:07:31 -0700 | [diff] [blame] | 285 | tcp_slow_start(tp, acked); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | /* Extract info for Tcp socket info provided via netlink. */ |
Eric Dumazet | 64f40ff | 2015-04-28 16:23:48 -0700 | [diff] [blame] | 289 | size_t tcp_vegas_get_info(struct sock *sk, u32 ext, int *attr, |
| 290 | union tcp_cc_info *info) |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 291 | { |
Arnaldo Carvalho de Melo | 6687e98 | 2005-08-10 04:03:31 -0300 | [diff] [blame] | 292 | const struct vegas *ca = inet_csk_ca(sk); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 293 | |
Eric Dumazet | 64f40ff | 2015-04-28 16:23:48 -0700 | [diff] [blame] | 294 | if (ext & (1 << (INET_DIAG_VEGASINFO - 1))) { |
| 295 | info->vegas.tcpv_enabled = ca->doing_vegas_now, |
| 296 | info->vegas.tcpv_rttcnt = ca->cntRTT, |
| 297 | info->vegas.tcpv_rtt = ca->baseRTT, |
| 298 | info->vegas.tcpv_minrtt = ca->minRTT, |
| 299 | |
| 300 | *attr = INET_DIAG_VEGASINFO; |
| 301 | return sizeof(struct tcpvegas_info); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 302 | } |
Eric Dumazet | 521f1cf | 2015-04-16 18:10:35 -0700 | [diff] [blame] | 303 | return 0; |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 304 | } |
Stephen Hemminger | 7752237 | 2007-04-23 22:28:23 -0700 | [diff] [blame] | 305 | EXPORT_SYMBOL_GPL(tcp_vegas_get_info); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 306 | |
Stephen Hemminger | a252beb | 2011-03-10 00:40:17 -0800 | [diff] [blame] | 307 | static struct tcp_congestion_ops tcp_vegas __read_mostly = { |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 308 | .init = tcp_vegas_init, |
| 309 | .ssthresh = tcp_reno_ssthresh, |
| 310 | .cong_avoid = tcp_vegas_cong_avoid, |
Stephen Hemminger | 164891a | 2007-04-23 22:26:16 -0700 | [diff] [blame] | 311 | .pkts_acked = tcp_vegas_pkts_acked, |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 312 | .set_state = tcp_vegas_state, |
| 313 | .cwnd_event = tcp_vegas_cwnd_event, |
| 314 | .get_info = tcp_vegas_get_info, |
| 315 | |
| 316 | .owner = THIS_MODULE, |
| 317 | .name = "vegas", |
| 318 | }; |
| 319 | |
| 320 | static int __init tcp_vegas_register(void) |
| 321 | { |
Alexey Dobriyan | 74975d4 | 2006-08-25 17:10:33 -0700 | [diff] [blame] | 322 | BUILD_BUG_ON(sizeof(struct vegas) > ICSK_CA_PRIV_SIZE); |
Stephen Hemminger | b87d856 | 2005-06-23 12:27:19 -0700 | [diff] [blame] | 323 | tcp_register_congestion_control(&tcp_vegas); |
| 324 | return 0; |
| 325 | } |
| 326 | |
| 327 | static void __exit tcp_vegas_unregister(void) |
| 328 | { |
| 329 | tcp_unregister_congestion_control(&tcp_vegas); |
| 330 | } |
| 331 | |
| 332 | module_init(tcp_vegas_register); |
| 333 | module_exit(tcp_vegas_unregister); |
| 334 | |
| 335 | MODULE_AUTHOR("Stephen Hemminger"); |
| 336 | MODULE_LICENSE("GPL"); |
| 337 | MODULE_DESCRIPTION("TCP Vegas"); |