Merge branch 'listener_refactor_16'

Eric Dumazet says:

====================
tcp: listener refactor part 16

A CONFIG_PROVE_RCU=y build revealed an RCU splat I had to fix.

I added const qualifiers to various md5 methods, as I expect
to call them on behalf of request sock traffic even if
the listener socket is not locked. This seems ok, but adding
const makes the contract clearer. Note a good reduction
of code size thanks to request/establish sockets convergence.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 14 insertions, 36 deletions

diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 4a4e6d30c448..a9568caf4675 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -486,17 +486,11 @@ static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
 }
 
 static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
-                                                struct sock *addr_sk)
+                                                const struct sock *addr_sk)
 {
         return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
 }
 
-static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
-                                                      struct request_sock *req)
-{
-        return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
-}
-
 static int tcp_v6_parse_md5_keys(struct sock *sk, char __user *optval,
                                  int optlen)
 {
@@ -582,9 +576,9 @@ clear_hash_noput:
         return 1;
 }
 
-static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
+static int tcp_v6_md5_hash_skb(char *md5_hash,
+                               const struct tcp_md5sig_key *key,
                                const struct sock *sk,
-                               const struct request_sock *req,
                                const struct sk_buff *skb)
 {
         const struct in6_addr *saddr, *daddr;
@@ -592,12 +586,9 @@ static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
         struct hash_desc *desc;
         const struct tcphdr *th = tcp_hdr(skb);
 
-        if (sk) {
-                saddr = &inet6_sk(sk)->saddr;
+        if (sk) { /* valid for establish/request sockets */
+                saddr = &sk->sk_v6_rcv_saddr;
                 daddr = &sk->sk_v6_daddr;
-        } else if (req) {
-                saddr = &inet_rsk(req)->ir_v6_loc_addr;
-                daddr = &inet_rsk(req)->ir_v6_rmt_addr;
         } else {
                 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
                 saddr = &ip6h->saddr;
@@ -633,8 +624,7 @@ clear_hash_noput:
         return 1;
 }
 
-static int __tcp_v6_inbound_md5_hash(struct sock *sk,
-                                     const struct sk_buff *skb)
+static bool tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
 {
         const __u8 *hash_location = NULL;
         struct tcp_md5sig_key *hash_expected;
@@ -648,44 +638,32 @@ static int __tcp_v6_inbound_md5_hash(struct sock *sk,
 
         /* We've parsed the options - do we have a hash? */
         if (!hash_expected && !hash_location)
-                return 0;
+                return false;
 
         if (hash_expected && !hash_location) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
-                return 1;
+                return true;
         }
 
         if (!hash_expected && hash_location) {
                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
-                return 1;
+                return true;
         }
 
         /* check the signature */
         genhash = tcp_v6_md5_hash_skb(newhash,
                                       hash_expected,
-                                      NULL, NULL, skb);
+                                      NULL, skb);
 
         if (genhash || memcmp(hash_location, newhash, 16) != 0) {
                 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
                                      genhash ? "failed" : "mismatch",
                                      &ip6h->saddr, ntohs(th->source),
                                      &ip6h->daddr, ntohs(th->dest));
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
-
-static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
-{
-        int ret;
-
-        rcu_read_lock();
-        ret = __tcp_v6_inbound_md5_hash(sk, skb);
-        rcu_read_unlock();
-
-        return ret;
-}
-
 #endif
 
 static void tcp_v6_init_req(struct request_sock *req, struct sock *sk,
@@ -736,7 +714,7 @@ static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
         .mss_clamp      =       IPV6_MIN_MTU - sizeof(struct tcphdr) -
                                 sizeof(struct ipv6hdr),
 #ifdef CONFIG_TCP_MD5SIG
-        .md5_lookup     =       tcp_v6_reqsk_md5_lookup,
+        .req_md5_lookup =       tcp_v6_md5_lookup,
         .calc_md5_hash  =       tcp_v6_md5_hash_skb,
 #endif
         .init_req       =       tcp_v6_init_req,
@@ -893,7 +871,7 @@ static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
                 if (!key)
                         goto release_sk1;
 
-                genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
+                genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, skb);
                 if (genhash || memcmp(hash_location, newhash, 16) != 0)
                         goto release_sk1;
         } else {