1 files changed, 116 insertions, 224 deletions

diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 77cccda1ad0c..94d1a7757ff7 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -72,7 +72,6 @@
 #include <net/inet_common.h>
 #include <net/timewait_sock.h>
 #include <net/xfrm.h>
-#include <net/netdma.h>
 #include <net/secure_seq.h>
 #include <net/tcp_memcontrol.h>
 #include <net/busy_poll.h>
@@ -90,7 +89,6 @@ int sysctl_tcp_tw_reuse __read_mostly;
 int sysctl_tcp_low_latency __read_mostly;
 EXPORT_SYMBOL(sysctl_tcp_low_latency);
 
-
 #ifdef CONFIG_TCP_MD5SIG
 static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
                                __be32 daddr, __be32 saddr, const struct tcphdr *th);
@@ -99,7 +97,7 @@ static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
 struct inet_hashinfo tcp_hashinfo;
 EXPORT_SYMBOL(tcp_hashinfo);
 
-static inline __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
+static  __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
 {
         return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
                                           ip_hdr(skb)->saddr,
@@ -208,6 +206,8 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
         inet->inet_dport = usin->sin_port;
         inet->inet_daddr = daddr;
 
+        inet_set_txhash(sk);
+
         inet_csk(sk)->icsk_ext_hdr_len = 0;
         if (inet_opt)
                 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
@@ -269,7 +269,7 @@ EXPORT_SYMBOL(tcp_v4_connect);
  * It can be called through tcp_release_cb() if socket was owned by user
  * at the time tcp_v4_err() was called to handle ICMP message.
  */
-static void tcp_v4_mtu_reduced(struct sock *sk)
+void tcp_v4_mtu_reduced(struct sock *sk)
 {
         struct dst_entry *dst;
         struct inet_sock *inet = inet_sk(sk);
@@ -300,6 +300,7 @@ static void tcp_v4_mtu_reduced(struct sock *sk)
                 tcp_simple_retransmit(sk);
         } /* else let the usual retransmit timer handle it */
 }
+EXPORT_SYMBOL(tcp_v4_mtu_reduced);
 
 static void do_redirect(struct sk_buff *skb, struct sock *sk)
 {
@@ -342,11 +343,6 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
         int err;
         struct net *net = dev_net(icmp_skb->dev);
 
-        if (icmp_skb->len < (iph->ihl << 2) + 8) {
-                ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
-                return;
-        }
-
         sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
                         iph->saddr, th->source, inet_iif(icmp_skb));
         if (!sk) {
@@ -433,15 +429,16 @@ void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
                         break;
 
                 icsk->icsk_backoff--;
-                inet_csk(sk)->icsk_rto = (tp->srtt_us ? __tcp_set_rto(tp) :
-                        TCP_TIMEOUT_INIT) << icsk->icsk_backoff;
-                tcp_bound_rto(sk);
+                icsk->icsk_rto = tp->srtt_us ? __tcp_set_rto(tp) :
+                                               TCP_TIMEOUT_INIT;
+                icsk->icsk_rto = inet_csk_rto_backoff(icsk, TCP_RTO_MAX);
 
                 skb = tcp_write_queue_head(sk);
                 BUG_ON(!skb);
 
-                remaining = icsk->icsk_rto - min(icsk->icsk_rto,
-                                tcp_time_stamp - TCP_SKB_CB(skb)->when);
+                remaining = icsk->icsk_rto -
+                            min(icsk->icsk_rto,
+                                tcp_time_stamp - tcp_skb_timestamp(skb));
 
                 if (remaining) {
                         inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
@@ -683,8 +680,9 @@ static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
 
         net = dev_net(skb_dst(skb)->dev);
         arg.tos = ip_hdr(skb)->tos;
-        ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
-                              ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
+        ip_send_unicast_reply(net, skb, &TCP_SKB_CB(skb)->header.h4.opt,
+                              ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
+                              &arg, arg.iov[0].iov_len);
 
         TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
         TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
@@ -766,8 +764,9 @@ static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
         if (oif)
                 arg.bound_dev_if = oif;
         arg.tos = tos;
-        ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
-                              ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
+        ip_send_unicast_reply(net, skb, &TCP_SKB_CB(skb)->header.h4.opt,
+                              ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
+                              &arg, arg.iov[0].iov_len);
 
         TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
 }
@@ -814,6 +813,7 @@ static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
  *      socket.
  */
 static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
+                              struct flowi *fl,
                               struct request_sock *req,
                               u16 queue_mapping,
                               struct tcp_fastopen_cookie *foc)
@@ -837,24 +837,11 @@ static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
                                             ireq->ir_rmt_addr,
                                             ireq->opt);
                 err = net_xmit_eval(err);
-                if (!tcp_rsk(req)->snt_synack && !err)
-                        tcp_rsk(req)->snt_synack = tcp_time_stamp;
         }
 
         return err;
 }
 
-static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req)
-{
-        int res = tcp_v4_send_synack(sk, NULL, req, 0, NULL);
-
-        if (!res) {
-                TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
-                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
-        }
-        return res;
-}
-
 /*
  *      IPv4 request_sock destructor.
  */
@@ -893,28 +880,6 @@ bool tcp_syn_flood_action(struct sock *sk,
 }
 EXPORT_SYMBOL(tcp_syn_flood_action);
 
-/*
- * Save and compile IPv4 options into the request_sock if needed.
- */
-static struct ip_options_rcu *tcp_v4_save_options(struct sk_buff *skb)
-{
-        const struct ip_options *opt = &(IPCB(skb)->opt);
-        struct ip_options_rcu *dopt = NULL;
-
-        if (opt && opt->optlen) {
-                int opt_size = sizeof(*dopt) + opt->optlen;
-
-                dopt = kmalloc(opt_size, GFP_ATOMIC);
-                if (dopt) {
-                        if (ip_options_echo(&dopt->opt, skb)) {
-                                kfree(dopt);
-                                dopt = NULL;
-                        }
-                }
-        }
-        return dopt;
-}
-
 #ifdef CONFIG_TCP_MD5SIG
 /*
  * RFC2385 MD5 checksumming requires a mapping of
@@ -1064,7 +1029,7 @@ static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
         if (sin->sin_family != AF_INET)
                 return -EINVAL;
 
-        if (!cmd.tcpm_key || !cmd.tcpm_keylen)
+        if (!cmd.tcpm_keylen)
                 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
                                       AF_INET);
 
@@ -1182,7 +1147,8 @@ clear_hash_noput:
 }
 EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
 
-static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
+static bool __tcp_v4_inbound_md5_hash(struct sock *sk,
+                                      const struct sk_buff *skb)
 {
         /*
          * This gets called for each TCP segment that arrives
@@ -1235,163 +1201,81 @@ static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
         return false;
 }
 
+static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
+{
+        bool ret;
+
+        rcu_read_lock();
+        ret = __tcp_v4_inbound_md5_hash(sk, skb);
+        rcu_read_unlock();
+
+        return ret;
+}
+
 #endif
 
+static void tcp_v4_init_req(struct request_sock *req, struct sock *sk,
+                            struct sk_buff *skb)
+{
+        struct inet_request_sock *ireq = inet_rsk(req);
+
+        ireq->ir_loc_addr = ip_hdr(skb)->daddr;
+        ireq->ir_rmt_addr = ip_hdr(skb)->saddr;
+        ireq->no_srccheck = inet_sk(sk)->transparent;
+        ireq->opt = tcp_v4_save_options(skb);
+}
+
+static struct dst_entry *tcp_v4_route_req(struct sock *sk, struct flowi *fl,
+                                          const struct request_sock *req,
+                                          bool *strict)
+{
+        struct dst_entry *dst = inet_csk_route_req(sk, &fl->u.ip4, req);
+
+        if (strict) {
+                if (fl->u.ip4.daddr == inet_rsk(req)->ir_rmt_addr)
+                        *strict = true;
+                else
+                        *strict = false;
+        }
+
+        return dst;
+}
+
 struct request_sock_ops tcp_request_sock_ops __read_mostly = {
         .family         =       PF_INET,
         .obj_size       =       sizeof(struct tcp_request_sock),
-        .rtx_syn_ack    =       tcp_v4_rtx_synack,
+        .rtx_syn_ack    =       tcp_rtx_synack,
         .send_ack       =       tcp_v4_reqsk_send_ack,
         .destructor     =       tcp_v4_reqsk_destructor,
         .send_reset     =       tcp_v4_send_reset,
-        .syn_ack_timeout =      tcp_syn_ack_timeout,
+        .syn_ack_timeout =      tcp_syn_ack_timeout,
 };
 
-#ifdef CONFIG_TCP_MD5SIG
 static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
+        .mss_clamp      =       TCP_MSS_DEFAULT,
+#ifdef CONFIG_TCP_MD5SIG
         .md5_lookup     =       tcp_v4_reqsk_md5_lookup,
         .calc_md5_hash  =       tcp_v4_md5_hash_skb,
-};
 #endif
+        .init_req       =       tcp_v4_init_req,
+#ifdef CONFIG_SYN_COOKIES
+        .cookie_init_seq =      cookie_v4_init_sequence,
+#endif
+        .route_req      =       tcp_v4_route_req,
+        .init_seq       =       tcp_v4_init_sequence,
+        .send_synack    =       tcp_v4_send_synack,
+        .queue_hash_add =       inet_csk_reqsk_queue_hash_add,
+};
 
 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 {
-        struct tcp_options_received tmp_opt;
-        struct request_sock *req;
-        struct inet_request_sock *ireq;
-        struct tcp_sock *tp = tcp_sk(sk);
-        struct dst_entry *dst = NULL;
-        __be32 saddr = ip_hdr(skb)->saddr;
-        __be32 daddr = ip_hdr(skb)->daddr;
-        __u32 isn = TCP_SKB_CB(skb)->when;
-        bool want_cookie = false, fastopen;
-        struct flowi4 fl4;
-        struct tcp_fastopen_cookie foc = { .len = -1 };
-        int err;
-
         /* Never answer to SYNs send to broadcast or multicast */
         if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
                 goto drop;
 
-        /* TW buckets are converted to open requests without
-         * limitations, they conserve resources and peer is
-         * evidently real one.
-         */
-        if ((sysctl_tcp_syncookies == 2 ||
-             inet_csk_reqsk_queue_is_full(sk)) && !isn) {
-                want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
-                if (!want_cookie)
-                        goto drop;
-        }
-
-        /* Accept backlog is full. If we have already queued enough
-         * of warm entries in syn queue, drop request. It is better than
-         * clogging syn queue with openreqs with exponentially increasing
-         * timeout.
-         */
-        if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
-                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
-                goto drop;
-        }
-
-        req = inet_reqsk_alloc(&tcp_request_sock_ops);
-        if (!req)
-                goto drop;
-
-#ifdef CONFIG_TCP_MD5SIG
-        tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
-#endif
-
-        tcp_clear_options(&tmp_opt);
-        tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
-        tmp_opt.user_mss  = tp->rx_opt.user_mss;
-        tcp_parse_options(skb, &tmp_opt, 0, want_cookie ? NULL : &foc);
-
-        if (want_cookie && !tmp_opt.saw_tstamp)
-                tcp_clear_options(&tmp_opt);
+        return tcp_conn_request(&tcp_request_sock_ops,
+                                &tcp_request_sock_ipv4_ops, sk, skb);
 
-        tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
-        tcp_openreq_init(req, &tmp_opt, skb);
-
-        ireq = inet_rsk(req);
-        ireq->ir_loc_addr = daddr;
-        ireq->ir_rmt_addr = saddr;
-        ireq->no_srccheck = inet_sk(sk)->transparent;
-        ireq->opt = tcp_v4_save_options(skb);
-        ireq->ir_mark = inet_request_mark(sk, skb);
-
-        if (security_inet_conn_request(sk, skb, req))
-                goto drop_and_free;
-
-        if (!want_cookie || tmp_opt.tstamp_ok)
-                TCP_ECN_create_request(req, skb, sock_net(sk));
-
-        if (want_cookie) {
-                isn = cookie_v4_init_sequence(sk, skb, &req->mss);
-                req->cookie_ts = tmp_opt.tstamp_ok;
-        } else if (!isn) {
-                /* VJ's idea. We save last timestamp seen
-                 * from the destination in peer table, when entering
-                 * state TIME-WAIT, and check against it before
-                 * accepting new connection request.
-                 *
-                 * If "isn" is not zero, this request hit alive
-                 * timewait bucket, so that all the necessary checks
-                 * are made in the function processing timewait state.
-                 */
-                if (tmp_opt.saw_tstamp &&
-                    tcp_death_row.sysctl_tw_recycle &&
-                    (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
-                    fl4.daddr == saddr) {
-                        if (!tcp_peer_is_proven(req, dst, true)) {
-                                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
-                                goto drop_and_release;
-                        }
-                }
-                /* Kill the following clause, if you dislike this way. */
-                else if (!sysctl_tcp_syncookies &&
-                         (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
-                          (sysctl_max_syn_backlog >> 2)) &&
-                         !tcp_peer_is_proven(req, dst, false)) {
-                        /* Without syncookies last quarter of
-                         * backlog is filled with destinations,
-                         * proven to be alive.
-                         * It means that we continue to communicate
-                         * to destinations, already remembered
-                         * to the moment of synflood.
-                         */
-                        LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("drop open request from %pI4/%u\n"),
-                                       &saddr, ntohs(tcp_hdr(skb)->source));
-                        goto drop_and_release;
-                }
-
-                isn = tcp_v4_init_sequence(skb);
-        }
-        if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
-                goto drop_and_free;
-
-        tcp_rsk(req)->snt_isn = isn;
-        tcp_rsk(req)->snt_synack = tcp_time_stamp;
-        tcp_openreq_init_rwin(req, sk, dst);
-        fastopen = !want_cookie &&
-                   tcp_try_fastopen(sk, skb, req, &foc, dst);
-        err = tcp_v4_send_synack(sk, dst, req,
-                                 skb_get_queue_mapping(skb), &foc);
-        if (!fastopen) {
-                if (err || want_cookie)
-                        goto drop_and_free;
-
-                tcp_rsk(req)->snt_synack = tcp_time_stamp;
-                tcp_rsk(req)->listener = NULL;
-                inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
-        }
-
-        return 0;
-
-drop_and_release:
-        dst_release(dst);
-drop_and_free:
-        reqsk_free(req);
 drop:
         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
         return 0;
@@ -1439,6 +1323,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
         newinet->mc_ttl       = ip_hdr(skb)->ttl;
         newinet->rcv_tos      = ip_hdr(skb)->tos;
         inet_csk(newsk)->icsk_ext_hdr_len = 0;
+        inet_set_txhash(newsk);
         if (inet_opt)
                 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
         newinet->inet_id = newtp->write_seq ^ jiffies;
@@ -1523,7 +1408,7 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
 
 #ifdef CONFIG_SYN_COOKIES
         if (!th->syn)
-                sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
+                sk = cookie_v4_check(sk, skb);
 #endif
         return sk;
 }
@@ -1539,16 +1424,6 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
 {
         struct sock *rsk;
-#ifdef CONFIG_TCP_MD5SIG
-        /*
-         * We really want to reject the packet as early as possible
-         * if:
-         *  o We're expecting an MD5'd packet and this is no MD5 tcp option
-         *  o There is an MD5 option and we're not expecting one
-         */
-        if (tcp_v4_inbound_md5_hash(sk, skb))
-                goto discard;
-#endif
 
         if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
                 struct dst_entry *dst = sk->sk_rx_dst;
@@ -1663,7 +1538,17 @@ bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
             skb_queue_len(&tp->ucopy.prequeue) == 0)
                 return false;
 
-        skb_dst_force(skb);
+        /* Before escaping RCU protected region, we need to take care of skb
+         * dst. Prequeue is only enabled for established sockets.
+         * For such sockets, we might need the skb dst only to set sk->sk_rx_dst
+         * Instead of doing full sk_rx_dst validity here, let's perform
+         * an optimistic check.
+         */
+        if (likely(sk->sk_rx_dst))
+                skb_dst_drop(skb);
+        else
+                skb_dst_force(skb);
+
         __skb_queue_tail(&tp->ucopy.prequeue, skb);
         tp->ucopy.memory += skb->truesize;
         if (tp->ucopy.memory > sk->sk_rcvbuf) {
@@ -1728,11 +1613,19 @@ int tcp_v4_rcv(struct sk_buff *skb)
 
         th = tcp_hdr(skb);
         iph = ip_hdr(skb);
+        /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
+         * barrier() makes sure compiler wont play fool^Waliasing games.
+         */
+        memmove(&TCP_SKB_CB(skb)->header.h4, IPCB(skb),
+                sizeof(struct inet_skb_parm));
+        barrier();
+
         TCP_SKB_CB(skb)->seq = ntohl(th->seq);
         TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
                                     skb->len - th->doff * 4);
         TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
-        TCP_SKB_CB(skb)->when    = 0;
+        TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
+        TCP_SKB_CB(skb)->tcp_tw_isn = 0;
         TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
         TCP_SKB_CB(skb)->sacked  = 0;
 
@@ -1751,6 +1644,18 @@ process:
 
         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
                 goto discard_and_relse;
+
+#ifdef CONFIG_TCP_MD5SIG
+        /*
+         * We really want to reject the packet as early as possible
+         * if:
+         *  o We're expecting an MD5'd packet and this is no MD5 tcp option
+         *  o There is an MD5 option and we're not expecting one
+         */
+        if (tcp_v4_inbound_md5_hash(sk, skb))
+                goto discard_and_relse;
+#endif
+
         nf_reset(skb);
 
         if (sk_filter(sk, skb))
@@ -1762,18 +1667,8 @@ process:
         bh_lock_sock_nested(sk);
         ret = 0;
         if (!sock_owned_by_user(sk)) {
-#ifdef CONFIG_NET_DMA
-                struct tcp_sock *tp = tcp_sk(sk);
-                if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
-                        tp->ucopy.dma_chan = net_dma_find_channel();
-                if (tp->ucopy.dma_chan)
+                if (!tcp_prequeue(sk, skb))
                         ret = tcp_v4_do_rcv(sk, skb);
-                else
-#endif
-                {
-                        if (!tcp_prequeue(sk, skb))
-                                ret = tcp_v4_do_rcv(sk, skb);
-                }
         } else if (unlikely(sk_add_backlog(sk, skb,
                                            sk->sk_rcvbuf + sk->sk_sndbuf))) {
                 bh_unlock_sock(sk);
@@ -1857,9 +1752,11 @@ void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
 
-        dst_hold(dst);
-        sk->sk_rx_dst = dst;
-        inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
+        if (dst) {
+                dst_hold(dst);
+                sk->sk_rx_dst = dst;
+                inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
+        }
 }
 EXPORT_SYMBOL(inet_sk_rx_dst_set);
 
@@ -1880,6 +1777,7 @@ const struct inet_connection_sock_af_ops ipv4_specific = {
         .compat_setsockopt = compat_ip_setsockopt,
         .compat_getsockopt = compat_ip_getsockopt,
 #endif
+        .mtu_reduced       = tcp_v4_mtu_reduced,
 };
 EXPORT_SYMBOL(ipv4_specific);
 
@@ -1932,11 +1830,6 @@ void tcp_v4_destroy_sock(struct sock *sk)
         }
 #endif
 
-#ifdef CONFIG_NET_DMA
-        /* Cleans up our sk_async_wait_queue */
-        __skb_queue_purge(&sk->sk_async_wait_queue);
-#endif
-
         /* Clean prequeue, it must be empty really */
         __skb_queue_purge(&tp->ucopy.prequeue);
 
@@ -2274,7 +2167,7 @@ int tcp_seq_open(struct inode *inode, struct file *file)
 
         s = ((struct seq_file *)file->private_data)->private;
         s->family               = afinfo->family;
-        s->last_pos             = 0;
+        s->last_pos             = 0;
         return 0;
 }
 EXPORT_SYMBOL(tcp_seq_open);
@@ -2499,7 +2392,6 @@ struct proto tcp_prot = {
         .sendpage               = tcp_sendpage,
         .backlog_rcv            = tcp_v4_do_rcv,
         .release_cb             = tcp_release_cb,
-        .mtu_reduced            = tcp_v4_mtu_reduced,
         .hash                   = inet_hash,
         .unhash                 = inet_unhash,
         .get_port               = inet_csk_get_port,