NFS: Don't use GFP_KERNEL in rpcsec_gss downcalls

[safe/jmp/linux-2.6] / net / ipv4 / tcp_veno.c

diff --git a/net/ipv4/tcp_veno.c b/net/ipv4/tcp_veno.c
index ce57bf3..b612acf 100644 (file)
--- a/net/ipv4/tcp_veno.c
+++ b/net/ipv4/tcp_veno.c
@@ -69,10 +69,16 @@ static void tcp_veno_init(struct sock *sk)
 }
 
 /* Do rtt sampling needed for Veno. */
-static void tcp_veno_rtt_calc(struct sock *sk, u32 usrtt)
+static void tcp_veno_pkts_acked(struct sock *sk, u32 cnt, s32 rtt_us)
 {
        struct veno *veno = inet_csk_ca(sk);
-       u32 vrtt = usrtt + 1;   /* Never allow zero rtt or basertt */
+       u32 vrtt;
+
+       if (rtt_us < 0)
+               return;
+
+       /* Never allow zero rtt or baseRTT */
+       vrtt = rtt_us + 1;
 
        /* Filter to find propagation delay: */
        if (vrtt < veno->basertt)
@@ -108,14 +114,15 @@ static void tcp_veno_cwnd_event(struct sock *sk, enum tcp_ca_event event)
                tcp_veno_init(sk);
 }
 
-static void tcp_veno_cong_avoid(struct sock *sk, u32 ack,
-                               u32 seq_rtt, u32 in_flight, int flag)
+static void tcp_veno_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct veno *veno = inet_csk_ca(sk);
 
-       if (!veno->doing_veno_now)
-               return tcp_reno_cong_avoid(sk, ack, seq_rtt, in_flight, flag);
+       if (!veno->doing_veno_now) {
+               tcp_reno_cong_avoid(sk, ack, in_flight);
+               return;
+       }
 
        /* limited by applications */
        if (!tcp_is_cwnd_limited(sk, in_flight))
@@ -126,9 +133,10 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack,
                /* We don't have enough rtt samples to do the Veno
                 * calculation, so we'll behave like Reno.
                 */
-               tcp_reno_cong_avoid(sk, ack, seq_rtt, in_flight, flag);
+               tcp_reno_cong_avoid(sk, ack, in_flight);
        } else {
-               u32 rtt, target_cwnd;
+               u64 target_cwnd;
+               u32 rtt;
 
                /* We have enough rtt samples, so, using the Veno
                 * algorithm, we determine the state of the network.
@@ -136,8 +144,9 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack,
 
                rtt = veno->minrtt;
 
-               target_cwnd = ((tp->snd_cwnd * veno->basertt)
-                              << V_PARAM_SHIFT) / rtt;
+               target_cwnd = (tp->snd_cwnd * veno->basertt);
+               target_cwnd <<= V_PARAM_SHIFT;
+               do_div(target_cwnd, rtt);
 
                veno->diff = (tp->snd_cwnd << V_PARAM_SHIFT) - target_cwnd;
 
@@ -150,20 +159,14 @@ static void tcp_veno_cong_avoid(struct sock *sk, u32 ack,
                                /* In the "non-congestive state", increase cwnd
                                 *  every rtt.
                                 */
-                               if (tp->snd_cwnd_cnt >= tp->snd_cwnd) {
-                                       if (tp->snd_cwnd < tp->snd_cwnd_clamp)
-                                               tp->snd_cwnd++;
-                                       tp->snd_cwnd_cnt = 0;
-                               } else
-                                       tp->snd_cwnd_cnt++;
+                               tcp_cong_avoid_ai(tp, tp->snd_cwnd);
                        } else {
                                /* In the "congestive state", increase cwnd
                                 * every other rtt.
                                 */
                                if (tp->snd_cwnd_cnt >= tp->snd_cwnd) {
-                                       if (veno->inc
-                                           && tp->snd_cwnd <
-                                           tp->snd_cwnd_clamp) {
+                                       if (veno->inc &&
+                                           tp->snd_cwnd < tp->snd_cwnd_clamp) {
                                                tp->snd_cwnd++;
                                                veno->inc = 0;
                                        } else
@@ -199,10 +202,11 @@ static u32 tcp_veno_ssthresh(struct sock *sk)
 }
 
 static struct tcp_congestion_ops tcp_veno = {
+       .flags          = TCP_CONG_RTT_STAMP,
        .init           = tcp_veno_init,
        .ssthresh       = tcp_veno_ssthresh,
        .cong_avoid     = tcp_veno_cong_avoid,
-       .rtt_sample     = tcp_veno_rtt_calc,
+       .pkts_acked     = tcp_veno_pkts_acked,
        .set_state      = tcp_veno_state,
        .cwnd_event     = tcp_veno_cwnd_event,