1 files changed, 129 insertions, 21 deletions

diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 389deeb2a457..2cbe879ee16a 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -413,6 +413,135 @@ static inline void tcp_tso_set_push(struct sk_buff *skb)
                 TCP_SKB_CB(skb)->flags |= TCPCB_FLAG_PSH;
 }
 
+static void tcp_set_skb_tso_segs(struct sock *sk, struct sk_buff *skb)
+{
+        struct tcp_sock *tp = tcp_sk(sk);
+
+        if (skb->len <= tp->mss_cache_std ||
+            !(sk->sk_route_caps & NETIF_F_TSO)) {
+                /* Avoid the costly divide in the normal
+                 * non-TSO case.
+                 */
+                skb_shinfo(skb)->tso_segs = 1;
+                skb_shinfo(skb)->tso_size = 0;
+        } else {
+                unsigned int factor;
+
+                factor = skb->len + (tp->mss_cache_std - 1);
+                factor /= tp->mss_cache_std;
+                skb_shinfo(skb)->tso_segs = factor;
+                skb_shinfo(skb)->tso_size = tp->mss_cache_std;
+        }
+}
+
+static inline int tcp_minshall_check(const struct tcp_sock *tp)
+{
+        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.
+ * 2. Or it contains FIN.
+ * 3. Or TCP_NODELAY was set.
+ * 4. Or TCP_CORK is not set, and all sent packets are ACKed.
+ *    With Minshall's modification: all sent small packets are ACKed.
+ */
+
+static inline int tcp_nagle_check(const struct tcp_sock *tp,
+                                  const struct sk_buff *skb, 
+                                  unsigned mss_now, int nonagle)
+{
+        return (skb->len < mss_now &&
+                !(TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN) &&
+                ((nonagle&TCP_NAGLE_CORK) ||
+                 (!nonagle &&
+                  tp->packets_out &&
+                  tcp_minshall_check(tp))));
+}
+
+/* This checks if the data bearing packet SKB (usually sk->sk_send_head)
+ * should be put on the wire right now.
+ */
+static int tcp_snd_test(struct sock *sk, struct sk_buff *skb,
+                        unsigned cur_mss, int nonagle)
+{
+        struct tcp_sock *tp = tcp_sk(sk);
+        int pkts = tcp_skb_pcount(skb);
+
+        if (!pkts) {
+                tcp_set_skb_tso_segs(sk, skb);
+                pkts = tcp_skb_pcount(skb);
+        }
+
+        /*      RFC 1122 - section 4.2.3.4
+         *
+         *      We must queue if
+         *
+         *      a) The right edge of this frame exceeds the window
+         *      b) There are packets in flight and we have a small segment
+         *         [SWS avoidance and Nagle algorithm]
+         *         (part of SWS is done on packetization)
+         *         Minshall version sounds: there are no _small_
+         *         segments in flight. (tcp_nagle_check)
+         *      c) We have too many packets 'in flight'
+         *
+         *      Don't use the nagle rule for urgent data (or
+         *      for the final FIN -DaveM).
+         *
+         *      Also, Nagle rule does not apply to frames, which
+         *      sit in the middle of queue (they have no chances
+         *      to get new data) and if room at tail of skb is
+         *      not enough to save something seriously (<32 for now).
+         */
+
+        /* Don't be strict about the congestion window for the
+         * final FIN frame.  -DaveM
+         */
+        return (((nonagle&TCP_NAGLE_PUSH) || tp->urg_mode
+                 || !tcp_nagle_check(tp, skb, cur_mss, nonagle)) &&
+                (((tcp_packets_in_flight(tp) + (pkts-1)) < tp->snd_cwnd) ||
+                 (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)) &&
+                !after(TCP_SKB_CB(skb)->end_seq, tp->snd_una + tp->snd_wnd));
+}
+
+static inline int tcp_skb_is_last(const struct sock *sk, 
+                                  const struct sk_buff *skb)
+{
+        return skb->next == (struct sk_buff *)&sk->sk_write_queue;
+}
+
+/* Push out any pending frames which were held back due to
+ * TCP_CORK or attempt at coalescing tiny packets.
+ * The socket must be locked by the caller.
+ */
+void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
+                               unsigned cur_mss, int nonagle)
+{
+        struct sk_buff *skb = sk->sk_send_head;
+
+        if (skb) {
+                if (!tcp_skb_is_last(sk, skb))
+                        nonagle = TCP_NAGLE_PUSH;
+                if (!tcp_snd_test(sk, skb, cur_mss, nonagle) ||
+                    tcp_write_xmit(sk, nonagle))
+                        tcp_check_probe_timer(sk, tp);
+        }
+        tcp_cwnd_validate(sk, tp);
+}
+
+int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp)
+{
+        struct sk_buff *skb = sk->sk_send_head;
+
+        return (skb &&
+                tcp_snd_test(sk, skb, tcp_current_mss(sk, 1),
+                             (tcp_skb_is_last(sk, skb) ?
+                              TCP_NAGLE_PUSH :
+                              tp->nonagle)));
+}
+
+
 /* Send _single_ skb sitting at the send head. This function requires
  * true push pending frames to setup probe timer etc.
  */
@@ -434,27 +563,6 @@ void tcp_push_one(struct sock *sk, unsigned cur_mss)
         }
 }
 
-void tcp_set_skb_tso_segs(struct sock *sk, struct sk_buff *skb)
-{
-        struct tcp_sock *tp = tcp_sk(sk);
-
-        if (skb->len <= tp->mss_cache_std ||
-            !(sk->sk_route_caps & NETIF_F_TSO)) {
-                /* Avoid the costly divide in the normal
-                 * non-TSO case.
-                 */
-                skb_shinfo(skb)->tso_segs = 1;
-                skb_shinfo(skb)->tso_size = 0;
-        } else {
-                unsigned int factor;
-
-                factor = skb->len + (tp->mss_cache_std - 1);
-                factor /= tp->mss_cache_std;
-                skb_shinfo(skb)->tso_segs = factor;
-                skb_shinfo(skb)->tso_size = tp->mss_cache_std;
-        }
-}
-
 /* Function to create two new TCP segments.  Shrinks the given segment
  * to the specified size and appends a new segment with the rest of the
  * packet to the list.  This won't be called frequently, I hope.