1 files changed, 118 insertions, 12 deletions

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index c5aca0bb116a..1f3d52946b3b 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -277,8 +277,7 @@
 
 int sysctl_tcp_fin_timeout __read_mostly = TCP_FIN_TIMEOUT;
 
-atomic_t tcp_orphan_count = ATOMIC_INIT(0);
-
+struct percpu_counter tcp_orphan_count;
 EXPORT_SYMBOL_GPL(tcp_orphan_count);
 
 int sysctl_tcp_mem[3] __read_mostly;
@@ -290,9 +289,12 @@ EXPORT_SYMBOL(sysctl_tcp_rmem);
 EXPORT_SYMBOL(sysctl_tcp_wmem);
 
 atomic_t tcp_memory_allocated;  /* Current allocated memory. */
-atomic_t tcp_sockets_allocated; /* Current number of TCP sockets. */
-
 EXPORT_SYMBOL(tcp_memory_allocated);
+
+/*
+ * Current number of TCP sockets.
+ */
+struct percpu_counter tcp_sockets_allocated;
 EXPORT_SYMBOL(tcp_sockets_allocated);
 
 /*
@@ -1680,7 +1682,7 @@ void tcp_set_state(struct sock *sk, int state)
                         inet_put_port(sk);
                 /* fall through */
         default:
-                if (oldstate==TCP_ESTABLISHED)
+                if (oldstate == TCP_ESTABLISHED)
                         TCP_DEC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
         }
 
@@ -1690,7 +1692,7 @@ void tcp_set_state(struct sock *sk, int state)
         sk->sk_state = state;
 
 #ifdef STATE_TRACE
-        SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
+        SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n", sk, statename[oldstate], statename[state]);
 #endif
 }
 EXPORT_SYMBOL_GPL(tcp_set_state);
@@ -1834,7 +1836,7 @@ adjudge_to_death:
         state = sk->sk_state;
         sock_hold(sk);
         sock_orphan(sk);
-        atomic_inc(sk->sk_prot->orphan_count);
+        percpu_counter_inc(sk->sk_prot->orphan_count);
 
         /* It is the last release_sock in its life. It will remove backlog. */
         release_sock(sk);
@@ -1885,9 +1887,11 @@ adjudge_to_death:
                 }
         }
         if (sk->sk_state != TCP_CLOSE) {
+                int orphan_count = percpu_counter_read_positive(
+                                                sk->sk_prot->orphan_count);
+
                 sk_mem_reclaim(sk);
-                if (tcp_too_many_orphans(sk,
-                                atomic_read(sk->sk_prot->orphan_count))) {
+                if (tcp_too_many_orphans(sk, orphan_count)) {
                         if (net_ratelimit())
                                 printk(KERN_INFO "TCP: too many of orphaned "
                                        "sockets\n");
@@ -2461,6 +2465,106 @@ out:
 }
 EXPORT_SYMBOL(tcp_tso_segment);
 
+struct sk_buff **tcp_gro_receive(struct sk_buff **head, struct sk_buff *skb)
+{
+        struct sk_buff **pp = NULL;
+        struct sk_buff *p;
+        struct tcphdr *th;
+        struct tcphdr *th2;
+        unsigned int thlen;
+        unsigned int flags;
+        unsigned int total;
+        unsigned int mss = 1;
+        int flush = 1;
+
+        if (!pskb_may_pull(skb, sizeof(*th)))
+                goto out;
+
+        th = tcp_hdr(skb);
+        thlen = th->doff * 4;
+        if (thlen < sizeof(*th))
+                goto out;
+
+        if (!pskb_may_pull(skb, thlen))
+                goto out;
+
+        th = tcp_hdr(skb);
+        __skb_pull(skb, thlen);
+
+        flags = tcp_flag_word(th);
+
+        for (; (p = *head); head = &p->next) {
+                if (!NAPI_GRO_CB(p)->same_flow)
+                        continue;
+
+                th2 = tcp_hdr(p);
+
+                if (th->source != th2->source || th->dest != th2->dest) {
+                        NAPI_GRO_CB(p)->same_flow = 0;
+                        continue;
+                }
+
+                goto found;
+        }
+
+        goto out_check_final;
+
+found:
+        flush = NAPI_GRO_CB(p)->flush;
+        flush |= flags & TCP_FLAG_CWR;
+        flush |= (flags ^ tcp_flag_word(th2)) &
+                  ~(TCP_FLAG_CWR | TCP_FLAG_FIN | TCP_FLAG_PSH);
+        flush |= th->ack_seq != th2->ack_seq || th->window != th2->window;
+        flush |= memcmp(th + 1, th2 + 1, thlen - sizeof(*th));
+
+        total = p->len;
+        mss = total;
+        if (skb_shinfo(p)->frag_list)
+                mss = skb_shinfo(p)->frag_list->len;
+
+        flush |= skb->len > mss || skb->len <= 0;
+        flush |= ntohl(th2->seq) + total != ntohl(th->seq);
+
+        if (flush || skb_gro_receive(head, skb)) {
+                mss = 1;
+                goto out_check_final;
+        }
+
+        p = *head;
+        th2 = tcp_hdr(p);
+        tcp_flag_word(th2) |= flags & (TCP_FLAG_FIN | TCP_FLAG_PSH);
+
+out_check_final:
+        flush = skb->len < mss;
+        flush |= flags & (TCP_FLAG_URG | TCP_FLAG_PSH | TCP_FLAG_RST |
+                          TCP_FLAG_SYN | TCP_FLAG_FIN);
+
+        if (p && (!NAPI_GRO_CB(skb)->same_flow || flush))
+                pp = head;
+
+out:
+        NAPI_GRO_CB(skb)->flush |= flush;
+
+        return pp;
+}
+
+int tcp_gro_complete(struct sk_buff *skb)
+{
+        struct tcphdr *th = tcp_hdr(skb);
+
+        skb->csum_start = skb_transport_header(skb) - skb->head;
+        skb->csum_offset = offsetof(struct tcphdr, check);
+        skb->ip_summed = CHECKSUM_PARTIAL;
+
+        skb_shinfo(skb)->gso_size = skb_shinfo(skb)->frag_list->len;
+        skb_shinfo(skb)->gso_segs = NAPI_GRO_CB(skb)->count;
+
+        if (th->cwr)
+                skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
+
+        return 0;
+}
+
 #ifdef CONFIG_TCP_MD5SIG
 static unsigned long tcp_md5sig_users;
 static struct tcp_md5sig_pool **tcp_md5sig_pool;
@@ -2650,7 +2754,7 @@ EXPORT_SYMBOL(tcp_md5_hash_key);
 
 void tcp_done(struct sock *sk)
 {
-        if(sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
+        if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
                 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
 
         tcp_set_state(sk, TCP_CLOSE);
@@ -2685,6 +2789,8 @@ void __init tcp_init(void)
 
         BUILD_BUG_ON(sizeof(struct tcp_skb_cb) > sizeof(skb->cb));
 
+        percpu_counter_init(&tcp_sockets_allocated, 0);
+        percpu_counter_init(&tcp_orphan_count, 0);
         tcp_hashinfo.bind_bucket_cachep =
                 kmem_cache_create("tcp_bind_bucket",
                                   sizeof(struct inet_bind_bucket), 0,
@@ -2707,8 +2813,8 @@ void __init tcp_init(void)
                                         thash_entries ? 0 : 512 * 1024);
         tcp_hashinfo.ehash_size = 1 << tcp_hashinfo.ehash_size;
         for (i = 0; i < tcp_hashinfo.ehash_size; i++) {
-                INIT_HLIST_HEAD(&tcp_hashinfo.ehash[i].chain);
-                INIT_HLIST_HEAD(&tcp_hashinfo.ehash[i].twchain);
+                INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);
+                INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].twchain, i);
         }
         if (inet_ehash_locks_alloc(&tcp_hashinfo))
                 panic("TCP: failed to alloc ehash_locks");