tcp: instrument how long TCP is busy sending

[uclinux-h8/linux.git] / net / ipv4 / tcp_output.c

diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 896e9df..e8ea584 100644 (file)
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2081,6 +2081,47 @@ static bool tcp_small_queue_check(struct sock *sk, const struct sk_buff *skb,
        return false;
 }
 
+static void tcp_chrono_set(struct tcp_sock *tp, const enum tcp_chrono new)
+{
+       const u32 now = tcp_time_stamp;
+
+       if (tp->chrono_type > TCP_CHRONO_UNSPEC)
+               tp->chrono_stat[tp->chrono_type - 1] += now - tp->chrono_start;
+       tp->chrono_start = now;
+       tp->chrono_type = new;
+}
+
+void tcp_chrono_start(struct sock *sk, const enum tcp_chrono type)
+{
+       struct tcp_sock *tp = tcp_sk(sk);
+
+       /* If there are multiple conditions worthy of tracking in a
+        * chronograph then the highest priority enum takes precedence
+        * over the other conditions. So that if something "more interesting"
+        * starts happening, stop the previous chrono and start a new one.
+        */
+       if (type > tp->chrono_type)
+               tcp_chrono_set(tp, type);
+}
+
+void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type)
+{
+       struct tcp_sock *tp = tcp_sk(sk);
+
+
+       /* There are multiple conditions worthy of tracking in a
+        * chronograph, so that the highest priority enum takes
+        * precedence over the other conditions (see tcp_chrono_start).
+        * If a condition stops, we only stop chrono tracking if
+        * it's the "most interesting" or current chrono we are
+        * tracking and starts busy chrono if we have pending data.
+        */
+       if (tcp_write_queue_empty(sk))
+               tcp_chrono_set(tp, TCP_CHRONO_UNSPEC);
+       else if (type == tp->chrono_type)
+               tcp_chrono_set(tp, TCP_CHRONO_BUSY);
+}
+
 /* This routine writes packets to the network.  It advances the
  * send_head.  This happens as incoming acks open up the remote
  * window for us.
@@ -2514,7 +2555,7 @@ void tcp_skb_collapse_tstamp(struct sk_buff *skb,
 }
 
 /* Collapses two adjacent SKB's during retransmission. */
-static void tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
+static bool tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct sk_buff *next_skb = tcp_write_queue_next(sk, skb);
@@ -2525,13 +2566,17 @@ static void tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
 
        BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1);
 
+       if (next_skb_size) {
+               if (next_skb_size <= skb_availroom(skb))
+                       skb_copy_bits(next_skb, 0, skb_put(skb, next_skb_size),
+                                     next_skb_size);
+               else if (!skb_shift(skb, next_skb, next_skb_size))
+                       return false;
+       }
        tcp_highest_sack_combine(sk, next_skb, skb);
 
        tcp_unlink_write_queue(next_skb, sk);
 
-       skb_copy_from_linear_data(next_skb, skb_put(skb, next_skb_size),
-                                 next_skb_size);
-
        if (next_skb->ip_summed == CHECKSUM_PARTIAL)
                skb->ip_summed = CHECKSUM_PARTIAL;
 
@@ -2560,6 +2605,7 @@ static void tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
        tcp_skb_collapse_tstamp(skb, next_skb);
 
        sk_wmem_free_skb(sk, next_skb);
+       return true;
 }
 
 /* Check if coalescing SKBs is legal. */
@@ -2567,14 +2613,11 @@ static bool tcp_can_collapse(const struct sock *sk, const struct sk_buff *skb)
 {
        if (tcp_skb_pcount(skb) > 1)
                return false;
-       /* TODO: SACK collapsing could be used to remove this condition */
-       if (skb_shinfo(skb)->nr_frags != 0)
-               return false;
        if (skb_cloned(skb))
                return false;
        if (skb == tcp_send_head(sk))
                return false;
-       /* Some heurestics for collapsing over SACK'd could be invented */
+       /* Some heuristics for collapsing over SACK'd could be invented */
        if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
                return false;
 
@@ -2612,16 +2655,12 @@ static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to,
 
                if (space < 0)
                        break;
-               /* Punt if not enough space exists in the first SKB for
-                * the data in the second
-                */
-               if (skb->len > skb_availroom(to))
-                       break;
 
                if (after(TCP_SKB_CB(skb)->end_seq, tcp_wnd_end(tp)))
                        break;
 
-               tcp_collapse_retrans(sk, to);
+               if (!tcp_collapse_retrans(sk, to))
+                       break;
        }
 }
 
@@ -3300,6 +3339,8 @@ static int tcp_send_syn_data(struct sock *sk, struct sk_buff *syn)
        fo->copied = space;
 
        tcp_connect_queue_skb(sk, syn_data);
+       if (syn_data->len)
+               tcp_chrono_start(sk, TCP_CHRONO_BUSY);
 
        err = tcp_transmit_skb(sk, syn_data, 1, sk->sk_allocation);