Merge branch 'kvm-updates/2.6.27' of git://git.kernel.org/pub/scm/linux/kernel/git...

[pandora-kernel.git] / net / ipv4 / tcp_vegas.c

diff --git a/net/ipv4/tcp_vegas.c b/net/ipv4/tcp_vegas.c
index 914e030..14504da 100644 (file)
--- a/net/ipv4/tcp_vegas.c
+++ b/net/ipv4/tcp_vegas.c
@@ -112,16 +112,16 @@ EXPORT_SYMBOL_GPL(tcp_vegas_init);
  *   o min-filter RTT samples from a much longer window (forever for now)
  *     to find the propagation delay (baseRTT)
  */
-void tcp_vegas_pkts_acked(struct sock *sk, u32 cnt, ktime_t last)
+void tcp_vegas_pkts_acked(struct sock *sk, u32 cnt, s32 rtt_us)
 {
        struct vegas *vegas = inet_csk_ca(sk);
        u32 vrtt;
 
-       if (ktime_equal(last, net_invalid_timestamp()))
+       if (rtt_us < 0)
                return;
 
        /* Never allow zero rtt or baseRTT */
-       vrtt = ktime_to_us(net_timedelta(last)) + 1;
+       vrtt = rtt_us + 1;
 
        /* Filter to find propagation delay: */
        if (vrtt < vegas->baseRTT)
@@ -162,14 +162,15 @@ void tcp_vegas_cwnd_event(struct sock *sk, enum tcp_ca_event event)
 }
 EXPORT_SYMBOL_GPL(tcp_vegas_cwnd_event);
 
-static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack,
-                                u32 in_flight, int flag)
+static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct vegas *vegas = inet_csk_ca(sk);
 
-       if (!vegas->doing_vegas_now)
-               return tcp_reno_cong_avoid(sk, ack, in_flight, flag);
+       if (!vegas->doing_vegas_now) {
+               tcp_reno_cong_avoid(sk, ack, in_flight);
+               return;
+       }
 
        /* The key players are v_beg_snd_una and v_beg_snd_nxt.
         *
@@ -228,9 +229,10 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack,
                        /* We don't have enough RTT samples to do the Vegas
                         * calculation, so we'll behave like Reno.
                         */
-                       tcp_reno_cong_avoid(sk, ack, in_flight, flag);
+                       tcp_reno_cong_avoid(sk, ack, in_flight);
                } else {
-                       u32 rtt, target_cwnd, diff;
+                       u32 rtt, diff;
+                       u64 target_cwnd;
 
                        /* We have enough RTT samples, so, using the Vegas
                         * algorithm, we determine if we should increase or
@@ -253,8 +255,9 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack,
                         * We keep it as a fixed point number with
                         * V_PARAM_SHIFT bits to the right of the binary point.
                         */
-                       target_cwnd = ((old_wnd * vegas->baseRTT)
-                                      << V_PARAM_SHIFT) / rtt;
+                       target_cwnd = ((u64)old_wnd * vegas->baseRTT);
+                       target_cwnd <<= V_PARAM_SHIFT;
+                       do_div(target_cwnd, rtt);
 
                        /* Calculate the difference between the window we had,
                         * and the window we would like to have. This quantity
@@ -266,26 +269,25 @@ static void tcp_vegas_cong_avoid(struct sock *sk, u32 ack,
                         */
                        diff = (old_wnd << V_PARAM_SHIFT) - target_cwnd;
 
-                       if (tp->snd_cwnd <= tp->snd_ssthresh) {
-                               /* Slow start.  */
-                               if (diff > gamma) {
-                                       /* Going too fast. Time to slow down
-                                        * and switch to congestion avoidance.
-                                        */
-                                       tp->snd_ssthresh = 2;
-
-                                       /* Set cwnd to match the actual rate
-                                        * exactly:
-                                        *   cwnd = (actual rate) * baseRTT
-                                        * Then we add 1 because the integer
-                                        * truncation robs us of full link
-                                        * utilization.
-                                        */
-                                       tp->snd_cwnd = min(tp->snd_cwnd,
-                                                          (target_cwnd >>
-                                                           V_PARAM_SHIFT)+1);
+                       if (diff > gamma && tp->snd_ssthresh > 2 ) {
+                               /* Going too fast. Time to slow down
+                                * and switch to congestion avoidance.
+                                */
+                               tp->snd_ssthresh = 2;
+
+                               /* Set cwnd to match the actual rate
+                                * exactly:
+                                *   cwnd = (actual rate) * baseRTT
+                                * Then we add 1 because the integer
+                                * truncation robs us of full link
+                                * utilization.
+                                */
+                               tp->snd_cwnd = min(tp->snd_cwnd,
+                                                  ((u32)target_cwnd >>
+                                                   V_PARAM_SHIFT)+1);
 
-                               }
+                       } else if (tp->snd_cwnd <= tp->snd_ssthresh) {
+                               /* Slow start.  */
                                tcp_slow_start(tp);
                        } else {
                                /* Congestion avoidance. */