svn commit: r242252 - head/sys/netinet

[Andre Oppermann]

Author: andre
Date: Sun Oct 28 17:40:35 2012
New Revision: 242252
URL: http://svn.freebsd.org/changeset/base/242252

Log:
  Prevent a flurry of forced window updates when an application is
  doing small reads on a (partially) filled receive socket buffer.
  
  Normally one would a send a window update every time the available
  space in the socket buffer increases by two times MSS.  This leads
  to a flurry of window updates that do not provide any meaningful
  new information to the sender.  There still is available space in
  the window and the sender can continue sending data.  All window
  updates then get carried by the regular ACKs.  Only when the socket
  buffer was (almost) full and the window closed accordingly a window
  updates delivery new information and allows the sender to start
  sending more data again.
  
  Send window updates only every two MSS when the socket buffer
  has less than 1/8 space available, or the available space in the
  socket buffer increased by 1/4 its full capacity, or the socket
  buffer is very small.  The next regular data ACK will carry and
  report the exact window size again.
  
  Reported by:	sbruno
  Tested by:	darrenr
  Tested by:	Darren Baginski
  PR:		kern/116335
  MFC after:	2 weeks

Modified:
  head/sys/netinet/tcp_output.c

Modified: head/sys/netinet/tcp_output.c
==============================================================================
--- head/sys/netinet/tcp_output.c	Sun Oct 28 17:30:28 2012	(r242251)
+++ head/sys/netinet/tcp_output.c	Sun Oct 28 17:40:35 2012	(r242252)
@@ -545,23 +545,39 @@ after_sack_rexmit:
 	}
 
 	/*
-	 * Compare available window to amount of window
-	 * known to peer (as advertised window less
-	 * next expected input).  If the difference is at least two
-	 * max size segments, or at least 50% of the maximum possible
-	 * window, then want to send a window update to peer.
-	 * Skip this if the connection is in T/TCP half-open state.
+	 * Sending of standalone window updates.
+	 *
+	 * Window updates important when we close our window due to a full
+	 * socket buffer and are opening it again after the application
+	 * reads data from it.  Once the window has opened again and the
+	 * remote end starts to send again the ACK clock takes over and
+	 * provides the most current window information.
+	 *
+	 * We must avoid to the silly window syndrome whereas every read
+	 * from the receive buffer, no matter how small, causes a window
+	 * update to be sent.  We also should avoid sending a flurry of
+	 * window updates when the socket buffer had queued a lot of data
+	 * and the application is doing small reads.
+	 *
+	 * Prevent a flurry of pointless window updates by only sending
+	 * an update when we can increase the advertized window by more
+	 * than 1/4th of the socket buffer capacity.  When the buffer is
+	 * getting full or is very small be more aggressive and send an
+	 * update whenever we can increase by two mss sized segments.
+	 * In all other situations the ACK's to new incoming data will
+	 * carry further window increases.
 	 *
 	 * Don't send an independent window update if a delayed
 	 * ACK is pending (it will get piggy-backed on it) or the
 	 * remote side already has done a half-close and won't send
-	 * more data.
+	 * more data.  Skip this if the connection is in T/TCP
+	 * half-open state.
 	 */
 	if (recwin > 0 && !(tp->t_flags & TF_NEEDSYN) &&
 	    !(tp->t_flags & TF_DELACK) &&
 	    !TCPS_HAVERCVDFIN(tp->t_state)) {
 		/*
-		 * "adv" is the amount we can increase the window,
+		 * "adv" is the amount we could increase the window,
 		 * taking into account that we are limited by
 		 * TCP_MAXWIN << tp->rcv_scale.
 		 */
@@ -581,9 +597,11 @@ after_sack_rexmit:
 		 */
 		if (oldwin >> tp->rcv_scale == (adv + oldwin) >> tp->rcv_scale)
 			goto dontupdate;
-		if (adv >= (long) (2 * tp->t_maxseg))
-			goto send;
-		if (2 * adv >= (long) so->so_rcv.sb_hiwat)
+
+		if (adv >= (long)(2 * tp->t_maxseg) &&
+		    (adv >= (long)(so->so_rcv.sb_hiwat / 4) ||
+		     recwin <= (long)(so->so_rcv.sb_hiwat / 8) ||
+		     so->so_rcv.sb_hiwat <= 8 * tp->t_maxseg))
 			goto send;
 	}
 dontupdate: