Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

[linux-2.6] / net / ipv4 / tcp_input.c

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index a0660391213751360d9a941d5f0a5856dc2f1900..0f00966b1784b0f1f448053554a4719cbbe1c496 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -1109,27 +1109,36 @@ static int tcp_is_sackblock_valid(struct tcp_sock *tp, int is_dsack,
 /* Check for lost retransmit. This superb idea is borrowed from "ratehalving".
  * Event "C". Later note: FACK people cheated me again 8), we have to account
  * for reordering! Ugly, but should help.
+ *
+ * Search retransmitted skbs from write_queue that were sent when snd_nxt was
+ * less than what is now known to be received by the other end (derived from
+ * SACK blocks by the caller). Also calculate the lowest snd_nxt among the
+ * remaining retransmitted skbs to avoid some costly processing per ACKs.
  */
-static int tcp_mark_lost_retrans(struct sock *sk, u32 lost_retrans)
+static int tcp_mark_lost_retrans(struct sock *sk, u32 received_upto)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct sk_buff *skb;
        int flag = 0;
+       int cnt = 0;
+       u32 new_low_seq = 0;
 
        tcp_for_write_queue(skb, sk) {
                u32 ack_seq = TCP_SKB_CB(skb)->ack_seq;
 
                if (skb == tcp_send_head(sk))
                        break;
-               if (after(TCP_SKB_CB(skb)->seq, lost_retrans))
+               if (cnt == tp->retrans_out)
                        break;
                if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
                        continue;
 
-               if ((TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) &&
-                   after(lost_retrans, ack_seq) &&
+               if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS))
+                       continue;
+
+               if (after(received_upto, ack_seq) &&
                    (tcp_is_fack(tp) ||
-                    !before(lost_retrans,
+                    !before(received_upto,
                             ack_seq + tp->reordering * tp->mss_cache))) {
                        TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
                        tp->retrans_out -= tcp_skb_pcount(skb);
@@ -1143,8 +1152,16 @@ static int tcp_mark_lost_retrans(struct sock *sk, u32 lost_retrans)
                                flag |= FLAG_DATA_SACKED;
                                NET_INC_STATS_BH(LINUX_MIB_TCPLOSTRETRANSMIT);
                        }
+               } else {
+                       if (!new_low_seq || before(ack_seq, new_low_seq))
+                               new_low_seq = ack_seq;
+                       cnt += tcp_skb_pcount(skb);
                }
        }
+
+       if (tp->retrans_out)
+               tp->lost_retrans_low = new_low_seq;
+
        return flag;
 }
 
@@ -1225,7 +1242,7 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
        int num_sacks = (ptr[1] - TCPOLEN_SACK_BASE)>>3;
        int reord = tp->packets_out;
        int prior_fackets;
-       u32 lost_retrans = 0;
+       u32 highest_sack_end_seq = 0;
        int flag = 0;
        int found_dup_sack = 0;
        int cached_fack_count;
@@ -1396,11 +1413,6 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
                                continue;
                        }
 
-                       if ((sacked&TCPCB_SACKED_RETRANS) &&
-                           after(end_seq, TCP_SKB_CB(skb)->ack_seq) &&
-                           (!lost_retrans || after(end_seq, lost_retrans)))
-                               lost_retrans = end_seq;
-
                        if (!in_sack)
                                continue;
 
@@ -1454,9 +1466,10 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
                                if (fack_count > tp->fackets_out)
                                        tp->fackets_out = fack_count;
 
-                               if (after(TCP_SKB_CB(skb)->seq,
-                                   tp->highest_sack))
+                               if (after(TCP_SKB_CB(skb)->seq, tp->highest_sack)) {
                                        tp->highest_sack = TCP_SKB_CB(skb)->seq;
+                                       highest_sack_end_seq = TCP_SKB_CB(skb)->end_seq;
+                               }
                        } else {
                                if (dup_sack && (sacked&TCPCB_RETRANS))
                                        reord = min(fack_count, reord);
@@ -1476,8 +1489,10 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
                }
        }
 
-       if (lost_retrans && icsk->icsk_ca_state == TCP_CA_Recovery)
-               flag |= tcp_mark_lost_retrans(sk, lost_retrans);
+       if (tp->retrans_out &&
+           after(highest_sack_end_seq, tp->lost_retrans_low) &&
+           icsk->icsk_ca_state == TCP_CA_Recovery)
+               flag |= tcp_mark_lost_retrans(sk, highest_sack_end_seq);
 
        tcp_verify_left_out(tp);
 
@@ -1980,8 +1995,7 @@ static void tcp_verify_retransmit_hint(struct tcp_sock *tp,
 }
 
 /* Mark head of queue up as lost. */
-static void tcp_mark_head_lost(struct sock *sk,
-                              int packets, u32 high_seq)
+static void tcp_mark_head_lost(struct sock *sk, int packets)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct sk_buff *skb;
@@ -2004,7 +2018,7 @@ static void tcp_mark_head_lost(struct sock *sk,
                tp->lost_skb_hint = skb;
                tp->lost_cnt_hint = cnt;
                cnt += tcp_skb_pcount(skb);
-               if (cnt > packets || after(TCP_SKB_CB(skb)->end_seq, high_seq))
+               if (cnt > packets || after(TCP_SKB_CB(skb)->end_seq, tp->high_seq))
                        break;
                if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_SACKED_ACKED|TCPCB_LOST))) {
                        TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
@@ -2025,9 +2039,9 @@ static void tcp_update_scoreboard(struct sock *sk)
                int lost = tp->fackets_out - tp->reordering;
                if (lost <= 0)
                        lost = 1;
-               tcp_mark_head_lost(sk, lost, tp->high_seq);
+               tcp_mark_head_lost(sk, lost);
        } else {
-               tcp_mark_head_lost(sk, 1, tp->high_seq);
+               tcp_mark_head_lost(sk, 1);
        }
 
        /* New heuristics: it is possible only after we switched
@@ -2366,7 +2380,7 @@ tcp_fastretrans_alert(struct sock *sk, int pkts_acked, int flag)
            before(tp->snd_una, tp->high_seq) &&
            icsk->icsk_ca_state != TCP_CA_Open &&
            tp->fackets_out > tp->reordering) {
-               tcp_mark_head_lost(sk, tp->fackets_out-tp->reordering, tp->high_seq);
+               tcp_mark_head_lost(sk, tp->fackets_out - tp->reordering);
                NET_INC_STATS_BH(LINUX_MIB_TCPLOSS);
        }