fw/nsc-linux-2.6.29: comparison net/ipv4/tcp

equal deleted inserted replaced

-:0056487c491e
+:d1f6d8b6f81c
 #include <linux/module.h>
 /* People can turn this off for buggy TCP's found in printers etc. */
 int sysctl_tcp_retrans_collapse __read_mostly = 1;
-/* People can turn this on to  work with those rare, broken TCPs that
+/* People can turn this on to work with those rare, broken TCPs that
 * interpret the window field as a signed quantity.
 */
 int sysctl_tcp_workaround_signed_windows __read_mostly = 0;
 /* This limits the percentage of the congestion window which we
 		opts->tsecr = tp->rx_opt.ts_recent;
 		size += TCPOLEN_TSTAMP_ALIGNED;
 	}
 	if (likely(sysctl_tcp_window_scaling)) {
 		opts->ws = tp->rx_opt.rcv_wscale;
-		if(likely(opts->ws))
+		if (likely(opts->ws))
 			size += TCPOLEN_WSCALE_ALIGNED;
 	}
 	if (likely(sysctl_tcp_sack)) {
 		opts->options |= OPTION_SACK_ADVERTISE;
 		if (unlikely(!(OPTION_TS & opts->options)))
 	opts->mss = mss;
 	size += TCPOLEN_MSS_ALIGNED;
 	if (likely(ireq->wscale_ok)) {
 		opts->ws = ireq->rcv_wscale;
-		if(likely(opts->ws))
+		if (likely(opts->ws))
 			size += TCPOLEN_WSCALE_ALIGNED;
 	}
 	if (likely(doing_ts)) {
 		opts->options |= OPTION_TS;
 		opts->tsval = TCP_SKB_CB(skb)->when;
 	return tso_segs;
 }
 static inline int tcp_minshall_check(const struct tcp_sock *tp)
 {
-	return after(tp->snd_sml,tp->snd_una) &&
+	return after(tp->snd_sml, tp->snd_una) &&
 		!after(tp->snd_sml, tp->snd_nxt);
 }
 /* Return 0, if packet can be sent now without violation Nagle's rules:
 * 1. It is full sized.
 	if (icsk->icsk_ca_state != TCP_CA_Open)
 		goto send_now;
 	/* Defer for less than two clock ticks. */
 	if (tp->tso_deferred &&
-	    ((jiffies << 1) >> 1) - (tp->tso_deferred >> 1) > 1)
+	    (((u32)jiffies << 1) >> 1) - (tp->tso_deferred >> 1) > 1)
 		goto send_now;
 	in_flight = tcp_packets_in_flight(tp);
 	BUG_ON(tcp_skb_pcount(skb) <= 1 || (tp->snd_cwnd <= in_flight));
 * account rare use of URG, this is not a big flaw.
 *
 * Returns 1, if no segments are in flight and we have queued segments, but
 * cannot send anything now because of SWS or another problem.
 */
-static int tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle)
+static int tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
+			  int push_one, gfp_t gfp)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct sk_buff *skb;
 	unsigned int tso_segs, sent_pkts;
 	int cwnd_quota;
 	int result;
-	/* If we are closed, the bytes will have to remain here.
-	 * In time closedown will finish, we empty the write queue and all
-	 * will be happy.
-	 */
-	if (unlikely(sk->sk_state == TCP_CLOSE))
-		return 0;
 	sent_pkts = 0;
-	/* Do MTU probing. */
+	if (!push_one) {
-	if ((result = tcp_mtu_probe(sk)) == 0) {
+		/* Do MTU probing. */
-		return 0;
+		result = tcp_mtu_probe(sk);
-	} else if (result > 0) {
+		if (!result) {
-		sent_pkts = 1;
+			return 0;
+		} else if (result > 0) {
+			sent_pkts = 1;
+		}
 	}
 	while ((skb = tcp_send_head(sk))) {
 		unsigned int limit;
 			if (unlikely(!tcp_nagle_test(tp, skb, mss_now,
 						     (tcp_skb_is_last(sk, skb) ?
 						      nonagle : TCP_NAGLE_PUSH))))
 				break;
 		} else {
-			if (tcp_tso_should_defer(sk, skb))
+			if (!push_one && tcp_tso_should_defer(sk, skb))
 				break;
 		}
 		limit = mss_now;
 		if (tso_segs > 1 && !tcp_urg_mode(tp))
 		    unlikely(tso_fragment(sk, skb, limit, mss_now)))
 			break;
 		TCP_SKB_CB(skb)->when = tcp_time_stamp;
-		if (unlikely(tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC)))
+		if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
 			break;
 		/* Advance the send_head.  This one is sent out.
 		 * This call will increment packets_out.
 		 */
 		tcp_event_new_data_sent(sk, skb);
 		tcp_minshall_update(tp, mss_now, skb);
 		sent_pkts++;
+		if (push_one)
+			break;
 	}
 	if (likely(sent_pkts)) {
 		tcp_cwnd_validate(sk);
 		return 0;
 void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
 			       int nonagle)
 {
 	struct sk_buff *skb = tcp_send_head(sk);
-	if (skb) {
+	if (!skb)
-		if (tcp_write_xmit(sk, cur_mss, nonagle))
+		return;
-			tcp_check_probe_timer(sk);
-	}
+	/* If we are closed, the bytes will have to remain here.
+	 * In time closedown will finish, we empty the write queue and
+	 * all will be happy.
+	 */
+	if (unlikely(sk->sk_state == TCP_CLOSE))
+		return;
+	if (tcp_write_xmit(sk, cur_mss, nonagle, 0, GFP_ATOMIC))
+		tcp_check_probe_timer(sk);
 }
 /* Send _single_ skb sitting at the send head. This function requires
 * true push pending frames to setup probe timer etc.
 */
 void tcp_push_one(struct sock *sk, unsigned int mss_now)
 {
-	struct tcp_sock *tp = tcp_sk(sk);
 	struct sk_buff *skb = tcp_send_head(sk);
-	unsigned int tso_segs, cwnd_quota;
 	BUG_ON(!skb || skb->len < mss_now);
-	tso_segs = tcp_init_tso_segs(sk, skb, mss_now);
+	tcp_write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, sk->sk_allocation);
-	cwnd_quota = tcp_snd_test(sk, skb, mss_now, TCP_NAGLE_PUSH);
-	if (likely(cwnd_quota)) {
-		unsigned int limit;
-		BUG_ON(!tso_segs);
-		limit = mss_now;
-		if (tso_segs > 1 && !tcp_urg_mode(tp))
-			limit = tcp_mss_split_point(sk, skb, mss_now,
-						    cwnd_quota);
-		if (skb->len > limit &&
-		    unlikely(tso_fragment(sk, skb, limit, mss_now)))
-			return;
-		/* Send it out now. */
-		TCP_SKB_CB(skb)->when = tcp_time_stamp;
-		if (likely(!tcp_transmit_skb(sk, skb, 1, sk->sk_allocation))) {
-			tcp_event_new_data_sent(sk, skb);
-			tcp_cwnd_validate(sk);
-			return;
-		}
-	}
 }
 /* This function returns the amount that we can raise the
 * usable window based on the following constraints
 *
 	}
 	return window;
 }
-/* Attempt to collapse two adjacent SKB's during retransmission. */
+/* Collapses two adjacent SKB's during retransmission. */
-static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *skb,
+static void tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
-				     int mss_now)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct sk_buff *next_skb = tcp_write_queue_next(sk, skb);
 	int skb_size, next_skb_size;
 	u16 flags;
-	/* The first test we must make is that neither of these two
-	 * SKB's are still referenced by someone else.
-	 */
-	if (skb_cloned(skb) || skb_cloned(next_skb))
-		return;
 	skb_size = skb->len;
 	next_skb_size = next_skb->len;
 	flags = TCP_SKB_CB(skb)->flags;
-	/* Also punt if next skb has been SACK'd. */
-	if (TCP_SKB_CB(next_skb)->sacked & TCPCB_SACKED_ACKED)
-		return;
-	/* Next skb is out of window. */
-	if (after(TCP_SKB_CB(next_skb)->end_seq, tcp_wnd_end(tp)))
-		return;
-	/* Punt if not enough space exists in the first SKB for
-	 * the data in the second, or the total combined payload
-	 * would exceed the MSS.
-	 */
-	if ((next_skb_size > skb_tailroom(skb)) ||
-	    ((skb_size + next_skb_size) > mss_now))
-		return;
 	BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1);
 	tcp_highest_sack_combine(sk, next_skb, skb);
-	/* Ok.	We will be able to collapse the packet. */
 	tcp_unlink_write_queue(next_skb, sk);
 	skb_copy_from_linear_data(next_skb, skb_put(skb, next_skb_size),
 				  next_skb_size);
 		tp->retransmit_skb_hint = skb;
 	sk_wmem_free_skb(sk, next_skb);
 }
-/* Do a simple retransmit without using the backoff mechanisms in
+static int tcp_can_collapse(struct sock *sk, struct sk_buff *skb)
-* tcp_timer. This is used for path mtu discovery.
+{
-* The socket is already locked here.
+	if (tcp_skb_pcount(skb) > 1)
-*/
+		return 0;
-void tcp_simple_retransmit(struct sock *sk)
+	/* TODO: SACK collapsing could be used to remove this condition */
-{
+	if (skb_shinfo(skb)->nr_frags != 0)
-	const struct inet_connection_sock *icsk = inet_csk(sk);
+		return 0;
-	struct tcp_sock *tp = tcp_sk(sk);
+	if (skb_cloned(skb))
-	struct sk_buff *skb;
+		return 0;
-	unsigned int mss = tcp_current_mss(sk, 0);
+	if (skb == tcp_send_head(sk))
-	u32 prior_lost = tp->lost_out;
+		return 0;
+	/* Some heurestics for collapsing over SACK'd could be invented */
-	tcp_for_write_queue(skb, sk) {
+	if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
-		if (skb == tcp_send_head(sk))
+		return 0;
+	return 1;
+}
+static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to,
+				     int space)
+{
+	struct tcp_sock *tp = tcp_sk(sk);
+	struct sk_buff *skb = to, *tmp;
+	int first = 1;
+	if (!sysctl_tcp_retrans_collapse)
+		return;
+	if (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_SYN)
+		return;
+	tcp_for_write_queue_from_safe(skb, tmp, sk) {
+		if (!tcp_can_collapse(sk, skb))
 			break;
-		if (skb->len > mss &&
-		    !(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) {
+		space -= skb->len;
-			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
-				TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
+		if (first) {
-				tp->retrans_out -= tcp_skb_pcount(skb);
+			first = 0;
-			}
+			continue;
-			tcp_skb_mark_lost_uncond_verify(tp, skb);
 		}
-	}
+		if (space < 0)
-	tcp_clear_retrans_hints_partial(tp);
+			break;
+		/* Punt if not enough space exists in the first SKB for
-	if (prior_lost == tp->lost_out)
+		 * the data in the second
-		return;
+		 */
+		if (skb->len > skb_tailroom(to))
-	if (tcp_is_reno(tp))
+			break;
-		tcp_limit_reno_sacked(tp);
+		if (after(TCP_SKB_CB(skb)->end_seq, tcp_wnd_end(tp)))
-	tcp_verify_left_out(tp);
+			break;
-	/* Don't muck with the congestion window here.
+		tcp_collapse_retrans(sk, to);
-	 * Reason is that we do not increase amount of _data_
+	}
-	 * in network, but units changed and effective
-	 * cwnd/ssthresh really reduced now.
-	 */
-	if (icsk->icsk_ca_state != TCP_CA_Loss) {
-		tp->high_seq = tp->snd_nxt;
-		tp->snd_ssthresh = tcp_current_ssthresh(sk);
-		tp->prior_ssthresh = 0;
-		tp->undo_marker = 0;
-		tcp_set_ca_state(sk, TCP_CA_Loss);
-	}
-	tcp_xmit_retransmit_queue(sk);
 }
 /* This retransmits one SKB.  Policy decisions and retransmit queue
 * state updates are done by the caller.  Returns non-zero if an
 * error occurred which prevented the send.
 	if (skb->len > cur_mss) {
 		if (tcp_fragment(sk, skb, cur_mss, cur_mss))
 			return -ENOMEM; /* We'll try again later. */
 	}
-	/* Collapse two adjacent packets if worthwhile and we can. */
+	tcp_retrans_try_collapse(sk, skb, cur_mss);
-	if (!(TCP_SKB_CB(skb)->flags & TCPCB_FLAG_SYN) &&
-	    (skb->len < (cur_mss >> 1)) &&
-	    (!tcp_skb_is_last(sk, skb)) &&
-	    (tcp_write_queue_next(sk, skb) != tcp_send_head(sk)) &&
-	    (skb_shinfo(skb)->nr_frags == 0 &&
-	     skb_shinfo(tcp_write_queue_next(sk, skb))->nr_frags == 0) &&
-	    (tcp_skb_pcount(skb) == 1 &&
-	     tcp_skb_pcount(tcp_write_queue_next(sk, skb)) == 1) &&
-	    (sysctl_tcp_retrans_collapse != 0))
-		tcp_retrans_try_collapse(sk, skb, cur_mss);
 	/* Some Solaris stacks overoptimize and ignore the FIN on a
 	 * retransmit when old data is attached.  So strip it off
 	 * since it is cheap to do so and saves bytes on the network.
 	 */
 	} else {
 		skb = tcp_write_queue_head(sk);
 		last_lost = tp->snd_una;
 	}
-	/* First pass: retransmit lost packets. */
 	tcp_for_write_queue_from(skb, sk) {
 		__u8 sacked = TCP_SKB_CB(skb)->sacked;
 		if (skb == tcp_send_head(sk))
 			break;

changeset 2	d1f6d8b6f81c
parent 0	aa628870c1d3