2 files changed, 17 insertions, 5 deletions

diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 0e058a2d1c6d..2d36f6db3706 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -342,6 +342,8 @@ struct tcp_sock {
 
         unsigned long last_synq_overflow; 
 
+        __u32   tso_deferred;
+
 /* Receiver side RTT estimation */
         struct {
                 __u32   rtt;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index f22536e32cb1..ca406157724c 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1096,10 +1096,14 @@ static int tcp_tso_should_defer(struct sock *sk, struct tcp_sock *tp, struct sk_
         u32 send_win, cong_win, limit, in_flight;
 
         if (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)
-                return 0;
+                goto send_now;
 
         if (icsk->icsk_ca_state != TCP_CA_Open)
-                return 0;
+                goto send_now;
+
+        /* Defer for less than two clock ticks. */
+        if (!tp->tso_deferred && ((jiffies<<1)>>1) - (tp->tso_deferred>>1) > 1)
+                goto send_now;
 
         in_flight = tcp_packets_in_flight(tp);
 
@@ -1115,7 +1119,7 @@ static int tcp_tso_should_defer(struct sock *sk, struct tcp_sock *tp, struct sk_
 
         /* If a full-sized TSO skb can be sent, do it. */
         if (limit >= 65536)
-                return 0;
+                goto send_now;
 
         if (sysctl_tcp_tso_win_divisor) {
                 u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache);
@@ -1125,7 +1129,7 @@ static int tcp_tso_should_defer(struct sock *sk, struct tcp_sock *tp, struct sk_
                  */
                 chunk /= sysctl_tcp_tso_win_divisor;
                 if (limit >= chunk)
-                        return 0;
+                        goto send_now;
         } else {
                 /* Different approach, try not to defer past a single
                  * ACK.  Receiver should ACK every other full sized
@@ -1133,11 +1137,17 @@ static int tcp_tso_should_defer(struct sock *sk, struct tcp_sock *tp, struct sk_
                  * then send now.
                  */
                 if (limit > tcp_max_burst(tp) * tp->mss_cache)
-                        return 0;
+                        goto send_now;
         }
 
         /* Ok, it looks like it is advisable to defer.  */
+        tp->tso_deferred = 1 | (jiffies<<1);
+
         return 1;
+
+send_now:
+        tp->tso_deferred = 0;
+        return 0;
 }
 
 /* Create a new MTU probe if we are ready.