tcp: TCP Fast Open Server - support TFO listeners
[linux-3.10.git] / net / ipv4 / af_inet.c
index cc14631..4f70ef0 100644 (file)
@@ -65,6 +65,8 @@
  *             2 of the License, or (at your option) any later version.
  */
 
+#define pr_fmt(fmt) "IPv4: " fmt
+
 #include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/types.h>
@@ -89,7 +91,6 @@
 #include <linux/slab.h>
 
 #include <asm/uaccess.h>
-#include <asm/system.h>
 
 #include <linux/inet.h>
 #include <linux/igmp.h>
@@ -148,6 +149,11 @@ void inet_sock_destruct(struct sock *sk)
                pr_err("Attempt to release alive inet socket %p\n", sk);
                return;
        }
+       if (sk->sk_type == SOCK_STREAM) {
+               struct fastopen_queue *fastopenq =
+                       inet_csk(sk)->icsk_accept_queue.fastopenq;
+               kfree(fastopenq);
+       }
 
        WARN_ON(atomic_read(&sk->sk_rmem_alloc));
        WARN_ON(atomic_read(&sk->sk_wmem_alloc));
@@ -156,6 +162,7 @@ void inet_sock_destruct(struct sock *sk)
 
        kfree(rcu_dereference_protected(inet->inet_opt, 1));
        dst_release(rcu_dereference_check(sk->sk_dst_cache, 1));
+       dst_release(sk->sk_rx_dst);
        sk_refcnt_debug_dec(sk);
 }
 EXPORT_SYMBOL(inet_sock_destruct);
@@ -210,6 +217,26 @@ int inet_listen(struct socket *sock, int backlog)
         * we can only allow the backlog to be adjusted.
         */
        if (old_state != TCP_LISTEN) {
+               /* Check special setups for testing purpose to enable TFO w/o
+                * requiring TCP_FASTOPEN sockopt.
+                * Note that only TCP sockets (SOCK_STREAM) will reach here.
+                * Also fastopenq may already been allocated because this
+                * socket was in TCP_LISTEN state previously but was
+                * shutdown() (rather than close()).
+                */
+               if ((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) != 0 &&
+                   inet_csk(sk)->icsk_accept_queue.fastopenq == NULL) {
+                       if ((sysctl_tcp_fastopen & TFO_SERVER_WO_SOCKOPT1) != 0)
+                               err = fastopen_init_queue(sk, backlog);
+                       else if ((sysctl_tcp_fastopen &
+                                 TFO_SERVER_WO_SOCKOPT2) != 0)
+                               err = fastopen_init_queue(sk,
+                                   ((uint)sysctl_tcp_fastopen) >> 16);
+                       else
+                               err = 0;
+                       if (err)
+                               goto out;
+               }
                err = inet_csk_listen_start(sk, backlog);
                if (err)
                        goto out;
@@ -241,20 +268,18 @@ void build_ehash_secret(void)
 }
 EXPORT_SYMBOL(build_ehash_secret);
 
-static inline int inet_netns_ok(struct net *net, int protocol)
+static inline int inet_netns_ok(struct net *net, __u8 protocol)
 {
-       int hash;
        const struct net_protocol *ipprot;
 
        if (net_eq(net, &init_net))
                return 1;
 
-       hash = protocol & (MAX_INET_PROTOS - 1);
-       ipprot = rcu_dereference(inet_protos[hash]);
-
-       if (ipprot == NULL)
+       ipprot = rcu_dereference(inet_protos[protocol]);
+       if (ipprot == NULL) {
                /* raw IP is OK */
                return 1;
+       }
        return ipprot->netns_ok;
 }
 
@@ -349,7 +374,7 @@ lookup_protocol:
        err = 0;
        sk->sk_no_check = answer_no_check;
        if (INET_PROTOSW_REUSE & answer_flags)
-               sk->sk_reuse = 1;
+               sk->sk_reuse = SK_CAN_REUSE;
 
        inet = inet_sk(sk);
        inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
@@ -381,6 +406,7 @@ lookup_protocol:
        inet->mc_all    = 1;
        inet->mc_index  = 0;
        inet->mc_list   = NULL;
+       inet->rcv_tos   = 0;
 
        sk_refcnt_debug_inc(sk);
 
@@ -465,6 +491,16 @@ int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
        if (addr_len < sizeof(struct sockaddr_in))
                goto out;
 
+       if (addr->sin_family != AF_INET) {
+               /* Compatibility games : accept AF_UNSPEC (mapped to AF_INET)
+                * only if s_addr is INADDR_ANY.
+                */
+               err = -EAFNOSUPPORT;
+               if (addr->sin_family != AF_UNSPEC ||
+                   addr->sin_addr.s_addr != htonl(INADDR_ANY))
+                       goto out;
+       }
+
        chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
 
        /* Not specified by any standard per-se, however it breaks too
@@ -529,7 +565,7 @@ out:
 }
 EXPORT_SYMBOL(inet_bind);
 
-int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
+int inet_dgram_connect(struct socket *sock, struct sockaddr *uaddr,
                       int addr_len, int flags)
 {
        struct sock *sk = sock->sk;
@@ -541,15 +577,16 @@ int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
 
        if (!inet_sk(sk)->inet_num && inet_autobind(sk))
                return -EAGAIN;
-       return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
+       return sk->sk_prot->connect(sk, uaddr, addr_len);
 }
 EXPORT_SYMBOL(inet_dgram_connect);
 
-static long inet_wait_for_connect(struct sock *sk, long timeo)
+static long inet_wait_for_connect(struct sock *sk, long timeo, int writebias)
 {
        DEFINE_WAIT(wait);
 
        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
+       sk->sk_write_pending += writebias;
 
        /* Basic assumption: if someone sets sk->sk_err, he _must_
         * change state of the socket from TCP_SYN_*.
@@ -565,6 +602,7 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
                prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
        }
        finish_wait(sk_sleep(sk), &wait);
+       sk->sk_write_pending -= writebias;
        return timeo;
 }
 
@@ -572,8 +610,8 @@ static long inet_wait_for_connect(struct sock *sk, long timeo)
  *     Connect to a remote host. There is regrettably still a little
  *     TCP 'magic' in here.
  */
-int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
-                       int addr_len, int flags)
+int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
+                         int addr_len, int flags)
 {
        struct sock *sk = sock->sk;
        int err;
@@ -582,8 +620,6 @@ int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
        if (addr_len < sizeof(uaddr->sa_family))
                return -EINVAL;
 
-       lock_sock(sk);
-
        if (uaddr->sa_family == AF_UNSPEC) {
                err = sk->sk_prot->disconnect(sk, flags);
                sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
@@ -623,8 +659,12 @@ int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
        timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
 
        if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
+               int writebias = (sk->sk_protocol == IPPROTO_TCP) &&
+                               tcp_sk(sk)->fastopen_req &&
+                               tcp_sk(sk)->fastopen_req->data ? 1 : 0;
+
                /* Error code is set above */
-               if (!timeo || !inet_wait_for_connect(sk, timeo))
+               if (!timeo || !inet_wait_for_connect(sk, timeo, writebias))
                        goto out;
 
                err = sock_intr_errno(timeo);
@@ -646,7 +686,6 @@ int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
        sock->state = SS_CONNECTED;
        err = 0;
 out:
-       release_sock(sk);
        return err;
 
 sock_error:
@@ -656,6 +695,18 @@ sock_error:
                sock->state = SS_DISCONNECTING;
        goto out;
 }
+EXPORT_SYMBOL(__inet_stream_connect);
+
+int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
+                       int addr_len, int flags)
+{
+       int err;
+
+       lock_sock(sock->sk);
+       err = __inet_stream_connect(sock, uaddr, addr_len, flags);
+       release_sock(sock->sk);
+       return err;
+}
 EXPORT_SYMBOL(inet_stream_connect);
 
 /*
@@ -673,8 +724,10 @@ int inet_accept(struct socket *sock, struct socket *newsock, int flags)
 
        lock_sock(sk2);
 
+       sock_rps_record_flow(sk2);
        WARN_ON(!((1 << sk2->sk_state) &
-                 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE)));
+                 (TCPF_ESTABLISHED | TCPF_SYN_RECV |
+                 TCPF_CLOSE_WAIT | TCPF_CLOSE)));
 
        sock_graft(sk2, newsock);
 
@@ -882,7 +935,7 @@ int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 EXPORT_SYMBOL(inet_ioctl);
 
 #ifdef CONFIG_COMPAT
-int inet_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
+static int inet_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
        struct sock *sk = sock->sk;
        int err = -ENOIOCTLCMD;
@@ -1073,13 +1126,11 @@ out:
        return;
 
 out_permanent:
-       printk(KERN_ERR "Attempt to override permanent protocol %d.\n",
-              protocol);
+       pr_err("Attempt to override permanent protocol %d\n", protocol);
        goto out;
 
 out_illegal:
-       printk(KERN_ERR
-              "Ignoring attempt to register invalid socket type %d.\n",
+       pr_err("Ignoring attempt to register invalid socket type %d\n",
               p->type);
        goto out;
 }
@@ -1088,8 +1139,7 @@ EXPORT_SYMBOL(inet_register_protosw);
 void inet_unregister_protosw(struct inet_protosw *p)
 {
        if (INET_PROTOSW_PERMANENT & p->flags) {
-               printk(KERN_ERR
-                      "Attempt to unregister permanent protocol %d.\n",
+               pr_err("Attempt to unregister permanent protocol %d\n",
                       p->protocol);
        } else {
                spin_lock_bh(&inetsw_lock);
@@ -1138,8 +1188,8 @@ static int inet_sk_reselect_saddr(struct sock *sk)
                return 0;
 
        if (sysctl_ip_dynaddr > 1) {
-               printk(KERN_INFO "%s(): shifting inet->saddr from %pI4 to %pI4\n",
-                      __func__, &old_saddr, &new_saddr);
+               pr_info("%s(): shifting inet->saddr from %pI4 to %pI4\n",
+                       __func__, &old_saddr, &new_saddr);
        }
 
        inet->inet_saddr = inet->inet_rcv_saddr = new_saddr;
@@ -1206,8 +1256,8 @@ EXPORT_SYMBOL(inet_sk_rebuild_header);
 
 static int inet_gso_send_check(struct sk_buff *skb)
 {
-       const struct iphdr *iph;
        const struct net_protocol *ops;
+       const struct iphdr *iph;
        int proto;
        int ihl;
        int err = -EINVAL;
@@ -1226,7 +1276,7 @@ static int inet_gso_send_check(struct sk_buff *skb)
        __skb_pull(skb, ihl);
        skb_reset_transport_header(skb);
        iph = ip_hdr(skb);
-       proto = iph->protocol & (MAX_INET_PROTOS - 1);
+       proto = iph->protocol;
        err = -EPROTONOSUPPORT;
 
        rcu_read_lock();
@@ -1239,11 +1289,12 @@ out:
        return err;
 }
 
-static struct sk_buff *inet_gso_segment(struct sk_buff *skb, u32 features)
+static struct sk_buff *inet_gso_segment(struct sk_buff *skb,
+       netdev_features_t features)
 {
        struct sk_buff *segs = ERR_PTR(-EINVAL);
-       struct iphdr *iph;
        const struct net_protocol *ops;
+       struct iphdr *iph;
        int proto;
        int ihl;
        int id;
@@ -1275,7 +1326,7 @@ static struct sk_buff *inet_gso_segment(struct sk_buff *skb, u32 features)
        skb_reset_transport_header(skb);
        iph = ip_hdr(skb);
        id = ntohs(iph->id);
-       proto = iph->protocol & (MAX_INET_PROTOS - 1);
+       proto = iph->protocol;
        segs = ERR_PTR(-EPROTONOSUPPORT);
 
        rcu_read_lock();
@@ -1329,7 +1380,7 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
                        goto out;
        }
 
-       proto = iph->protocol & (MAX_INET_PROTOS - 1);
+       proto = iph->protocol;
 
        rcu_read_lock();
        ops = rcu_dereference(inet_protos[proto]);
@@ -1339,7 +1390,7 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
        if (*(u8 *)iph != 0x45)
                goto out_unlock;
 
-       if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
+       if (unlikely(ip_fast_csum((u8 *)iph, 5)))
                goto out_unlock;
 
        id = ntohl(*(__be32 *)&iph->id);
@@ -1355,7 +1406,6 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
                iph2 = ip_hdr(p);
 
                if ((iph->protocol ^ iph2->protocol) |
-                   (iph->tos ^ iph2->tos) |
                    ((__force u32)iph->saddr ^ (__force u32)iph2->saddr) |
                    ((__force u32)iph->daddr ^ (__force u32)iph2->daddr)) {
                        NAPI_GRO_CB(p)->same_flow = 0;
@@ -1365,6 +1415,7 @@ static struct sk_buff **inet_gro_receive(struct sk_buff **head,
                /* All fields must match except length and checksum. */
                NAPI_GRO_CB(p)->flush |=
                        (iph->ttl ^ iph2->ttl) |
+                       (iph->tos ^ iph2->tos) |
                        ((u16)(ntohs(iph2->id) + NAPI_GRO_CB(p)->count) ^ id);
 
                NAPI_GRO_CB(p)->flush |= flush;
@@ -1387,11 +1438,11 @@ out:
 
 static int inet_gro_complete(struct sk_buff *skb)
 {
-       const struct net_protocol *ops;
+       __be16 newlen = htons(skb->len - skb_network_offset(skb));
        struct iphdr *iph = ip_hdr(skb);
-       int proto = iph->protocol & (MAX_INET_PROTOS - 1);
+       const struct net_protocol *ops;
+       int proto = iph->protocol;
        int err = -ENOSYS;
-       __be16 newlen = htons(skb->len - skb_network_offset(skb));
 
        csum_replace2(&iph->check, iph->tot_len, newlen);
        iph->tot_len = newlen;
@@ -1434,11 +1485,11 @@ EXPORT_SYMBOL_GPL(inet_ctl_sock_create);
 unsigned long snmp_fold_field(void __percpu *mib[], int offt)
 {
        unsigned long res = 0;
-       int i;
+       int i, j;
 
        for_each_possible_cpu(i) {
-               res += *(((unsigned long *) per_cpu_ptr(mib[0], i)) + offt);
-               res += *(((unsigned long *) per_cpu_ptr(mib[1], i)) + offt);
+               for (j = 0; j < SNMP_ARRAY_SZ; j++)
+                       res += *(((unsigned long *) per_cpu_ptr(mib[j], i)) + offt);
        }
        return res;
 }
@@ -1452,28 +1503,19 @@ u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t syncp_offset)
        int cpu;
 
        for_each_possible_cpu(cpu) {
-               void *bhptr, *userptr;
+               void *bhptr;
                struct u64_stats_sync *syncp;
-               u64 v_bh, v_user;
+               u64 v;
                unsigned int start;
 
-               /* first mib used by softirq context, we must use _bh() accessors */
-               bhptr = per_cpu_ptr(SNMP_STAT_BHPTR(mib), cpu);
+               bhptr = per_cpu_ptr(mib[0], cpu);
                syncp = (struct u64_stats_sync *)(bhptr + syncp_offset);
                do {
                        start = u64_stats_fetch_begin_bh(syncp);
-                       v_bh = *(((u64 *) bhptr) + offt);
+                       v = *(((u64 *) bhptr) + offt);
                } while (u64_stats_fetch_retry_bh(syncp, start));
 
-               /* second mib used in USER context */
-               userptr = per_cpu_ptr(SNMP_STAT_USRPTR(mib), cpu);
-               syncp = (struct u64_stats_sync *)(userptr + syncp_offset);
-               do {
-                       start = u64_stats_fetch_begin(syncp);
-                       v_user = *(((u64 *) userptr) + offt);
-               } while (u64_stats_fetch_retry(syncp, start));
-
-               res += v_bh + v_user;
+               res += v;
        }
        return res;
 }
@@ -1485,25 +1527,28 @@ int snmp_mib_init(void __percpu *ptr[2], size_t mibsize, size_t align)
        BUG_ON(ptr == NULL);
        ptr[0] = __alloc_percpu(mibsize, align);
        if (!ptr[0])
-               goto err0;
+               return -ENOMEM;
+#if SNMP_ARRAY_SZ == 2
        ptr[1] = __alloc_percpu(mibsize, align);
-       if (!ptr[1])
-               goto err1;
+       if (!ptr[1]) {
+               free_percpu(ptr[0]);
+               ptr[0] = NULL;
+               return -ENOMEM;
+       }
+#endif
        return 0;
-err1:
-       free_percpu(ptr[0]);
-       ptr[0] = NULL;
-err0:
-       return -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(snmp_mib_init);
 
-void snmp_mib_free(void __percpu *ptr[2])
+void snmp_mib_free(void __percpu *ptr[SNMP_ARRAY_SZ])
 {
+       int i;
+
        BUG_ON(ptr == NULL);
-       free_percpu(ptr[0]);
-       free_percpu(ptr[1]);
-       ptr[0] = ptr[1] = NULL;
+       for (i = 0; i < SNMP_ARRAY_SZ; i++) {
+               free_percpu(ptr[i]);
+               ptr[i] = NULL;
+       }
 }
 EXPORT_SYMBOL_GPL(snmp_mib_free);
 
@@ -1515,14 +1560,15 @@ static const struct net_protocol igmp_protocol = {
 #endif
 
 static const struct net_protocol tcp_protocol = {
-       .handler =      tcp_v4_rcv,
-       .err_handler =  tcp_v4_err,
-       .gso_send_check = tcp_v4_gso_send_check,
-       .gso_segment =  tcp_tso_segment,
-       .gro_receive =  tcp4_gro_receive,
-       .gro_complete = tcp4_gro_complete,
-       .no_policy =    1,
-       .netns_ok =     1,
+       .early_demux    =       tcp_v4_early_demux,
+       .handler        =       tcp_v4_rcv,
+       .err_handler    =       tcp_v4_err,
+       .gso_send_check =       tcp_v4_gso_send_check,
+       .gso_segment    =       tcp_tso_segment,
+       .gro_receive    =       tcp4_gro_receive,
+       .gro_complete   =       tcp4_gro_complete,
+       .no_policy      =       1,
+       .netns_ok       =       1,
 };
 
 static const struct net_protocol udp_protocol = {
@@ -1567,9 +1613,9 @@ static __net_init int ipv4_mib_init_net(struct net *net)
                          sizeof(struct icmp_mib),
                          __alignof__(struct icmp_mib)) < 0)
                goto err_icmp_mib;
-       if (snmp_mib_init((void __percpu **)net->mib.icmpmsg_statistics,
-                         sizeof(struct icmpmsg_mib),
-                         __alignof__(struct icmpmsg_mib)) < 0)
+       net->mib.icmpmsg_statistics = kzalloc(sizeof(struct icmpmsg_mib),
+                                             GFP_KERNEL);
+       if (!net->mib.icmpmsg_statistics)
                goto err_icmpmsg_mib;
 
        tcp_mib_init(net);
@@ -1593,7 +1639,7 @@ err_tcp_mib:
 
 static __net_exit void ipv4_mib_exit_net(struct net *net)
 {
-       snmp_mib_free((void __percpu **)net->mib.icmpmsg_statistics);
+       kfree(net->mib.icmpmsg_statistics);
        snmp_mib_free((void __percpu **)net->mib.icmp_statistics);
        snmp_mib_free((void __percpu **)net->mib.udplite_statistics);
        snmp_mib_free((void __percpu **)net->mib.udp_statistics);
@@ -1666,19 +1712,21 @@ static int __init inet_init(void)
        ip_static_sysctl_init();
 #endif
 
+       tcp_prot.sysctl_mem = init_net.ipv4.sysctl_tcp_mem;
+
        /*
         *      Add all the base protocols.
         */
 
        if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
+               pr_crit("%s: Cannot add ICMP protocol\n", __func__);
        if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
+               pr_crit("%s: Cannot add UDP protocol\n", __func__);
        if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
+               pr_crit("%s: Cannot add TCP protocol\n", __func__);
 #ifdef CONFIG_IP_MULTICAST
        if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
-               printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
+               pr_crit("%s: Cannot add IGMP protocol\n", __func__);
 #endif
 
        /* Register the socket-side information for inet_create. */
@@ -1725,14 +1773,14 @@ static int __init inet_init(void)
         */
 #if defined(CONFIG_IP_MROUTE)
        if (ip_mr_init())
-               printk(KERN_CRIT "inet_init: Cannot init ipv4 mroute\n");
+               pr_crit("%s: Cannot init ipv4 mroute\n", __func__);
 #endif
        /*
         *      Initialise per-cpu ipv4 mibs
         */
 
        if (init_ipv4_mibs())
-               printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n");
+               pr_crit("%s: Cannot init ipv4 mibs\n", __func__);
 
        ipv4_proc_init();