1 files changed, 79 insertions, 14 deletions

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 4a538bc1683d..e08245bdda3a 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -71,6 +71,7 @@
 #include <net/inet_common.h>
 #include <linux/ipsec.h>
 #include <asm/unaligned.h>
+#include <net/netdma.h>
 
 int sysctl_tcp_timestamps = 1;
 int sysctl_tcp_window_scaling = 1;
@@ -1649,7 +1650,7 @@ static void tcp_update_scoreboard(struct sock *sk, struct tcp_sock *tp)
          * Hence, we can detect timed out packets during fast
          * retransmit without falling to slow start.
          */
-        if (tcp_head_timedout(sk, tp)) {
+        if (!IsReno(tp) && tcp_head_timedout(sk, tp)) {
                 struct sk_buff *skb;
 
                 skb = tp->scoreboard_skb_hint ? tp->scoreboard_skb_hint
@@ -1662,8 +1663,6 @@ static void tcp_update_scoreboard(struct sock *sk, struct tcp_sock *tp)
                         if (!(TCP_SKB_CB(skb)->sacked&TCPCB_TAGBITS)) {
                                 TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
                                 tp->lost_out += tcp_skb_pcount(skb);
-                                if (IsReno(tp))
-                                        tcp_remove_reno_sacks(sk, tp, tcp_skb_pcount(skb) + 1);
 
                                 /* clear xmit_retrans hint */
                                 if (tp->retransmit_skb_hint &&
@@ -1690,17 +1689,26 @@ static inline void tcp_moderate_cwnd(struct tcp_sock *tp)
         tp->snd_cwnd_stamp = tcp_time_stamp;
 }
 
+/* Lower bound on congestion window is slow start threshold
+ * unless congestion avoidance choice decides to overide it.
+ */
+static inline u32 tcp_cwnd_min(const struct sock *sk)
+{
+        const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
+
+        return ca_ops->min_cwnd ? ca_ops->min_cwnd(sk) : tcp_sk(sk)->snd_ssthresh;
+}
+
 /* Decrease cwnd each second ack. */
 static void tcp_cwnd_down(struct sock *sk)
 {
-        const struct inet_connection_sock *icsk = inet_csk(sk);
         struct tcp_sock *tp = tcp_sk(sk);
         int decr = tp->snd_cwnd_cnt + 1;
 
         tp->snd_cwnd_cnt = decr&1;
         decr >>= 1;
 
-        if (decr && tp->snd_cwnd > icsk->icsk_ca_ops->min_cwnd(sk))
+        if (decr && tp->snd_cwnd > tcp_cwnd_min(sk))
                 tp->snd_cwnd -= decr;
 
         tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp)+1);
@@ -3787,6 +3795,50 @@ static inline int tcp_checksum_complete_user(struct sock *sk, struct sk_buff *sk
                 __tcp_checksum_complete_user(sk, skb);
 }
 
+#ifdef CONFIG_NET_DMA
+static int tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb, int hlen)
+{
+        struct tcp_sock *tp = tcp_sk(sk);
+        int chunk = skb->len - hlen;
+        int dma_cookie;
+        int copied_early = 0;
+
+        if (tp->ucopy.wakeup)
+                return 0;
+
+        if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
+                tp->ucopy.dma_chan = get_softnet_dma();
+
+        if (tp->ucopy.dma_chan && skb->ip_summed == CHECKSUM_UNNECESSARY) {
+
+                dma_cookie = dma_skb_copy_datagram_iovec(tp->ucopy.dma_chan,
+                        skb, hlen, tp->ucopy.iov, chunk, tp->ucopy.pinned_list);
+
+                if (dma_cookie < 0)
+                        goto out;
+
+                tp->ucopy.dma_cookie = dma_cookie;
+                copied_early = 1;
+
+                tp->ucopy.len -= chunk;
+                tp->copied_seq += chunk;
+                tcp_rcv_space_adjust(sk);
+
+                if ((tp->ucopy.len == 0) ||
+                    (tcp_flag_word(skb->h.th) & TCP_FLAG_PSH) ||
+                    (atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1))) {
+                        tp->ucopy.wakeup = 1;
+                        sk->sk_data_ready(sk, 0);
+                }
+        } else if (chunk > 0) {
+                tp->ucopy.wakeup = 1;
+                sk->sk_data_ready(sk, 0);
+        }
+out:
+        return copied_early;
+}
+#endif /* CONFIG_NET_DMA */
+
 /*
  *      TCP receive function for the ESTABLISHED state. 
  *
@@ -3888,8 +3940,6 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
                                     tp->rcv_nxt == tp->rcv_wup)
                                         tcp_store_ts_recent(tp);
 
-                                tcp_rcv_rtt_measure_ts(sk, skb);
-
                                 /* We know that such packets are checksummed
                                  * on entry.
                                  */
@@ -3903,14 +3953,23 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
                         }
                 } else {
                         int eaten = 0;
+                        int copied_early = 0;
 
-                        if (tp->ucopy.task == current &&
-                            tp->copied_seq == tp->rcv_nxt &&
-                            len - tcp_header_len <= tp->ucopy.len &&
-                            sock_owned_by_user(sk)) {
-                                __set_current_state(TASK_RUNNING);
+                        if (tp->copied_seq == tp->rcv_nxt &&
+                            len - tcp_header_len <= tp->ucopy.len) {
+#ifdef CONFIG_NET_DMA
+                                if (tcp_dma_try_early_copy(sk, skb, tcp_header_len)) {
+                                        copied_early = 1;
+                                        eaten = 1;
+                                }
+#endif
+                                if (tp->ucopy.task == current && sock_owned_by_user(sk) && !copied_early) {
+                                        __set_current_state(TASK_RUNNING);
 
-                                if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) {
+                                        if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))
+                                                eaten = 1;
+                                }
+                                if (eaten) {
                                         /* Predicted packet is in window by definition.
                                          * seq == rcv_nxt and rcv_wup <= rcv_nxt.
                                          * Hence, check seq<=rcv_wup reduces to:
@@ -3926,8 +3985,9 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
                                         __skb_pull(skb, tcp_header_len);
                                         tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
                                         NET_INC_STATS_BH(LINUX_MIB_TCPHPHITSTOUSER);
-                                        eaten = 1;
                                 }
+                                if (copied_early)
+                                        tcp_cleanup_rbuf(sk, skb->len);
                         }
                         if (!eaten) {
                                 if (tcp_checksum_complete_user(sk, skb))
@@ -3968,6 +4028,11 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
 
                         __tcp_ack_snd_check(sk, 0);
 no_ack:
+#ifdef CONFIG_NET_DMA
+                        if (copied_early)
+                                __skb_queue_tail(&sk->sk_async_wait_queue, skb);
+                        else
+#endif
                         if (eaten)
                                 __kfree_skb(skb);
                         else