Merge branch 'listen_refactor_part_13'

Eric Dumazet says:

====================
inet: tcp listener refactoring, part 13

inet_hash functions are in a bad state : Too much IPv6/IPv4 copy/pasting.

Lets refactor a bit.

Idea is that we do not want to have an equivalent of inet_csk(sk)->icsk_af_ops
for request socks in order to be able to use the right variant.

In this patch series, I started to let IPv6/IPv4 converge to common helpers.

Idea is to use ipv6_addr_set_v4mapped() even for AF_INET sockets, so that
we can test
       if (sk->sk_family == AF_INET6 &&
           !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
to tell if we deal with an IPv6 socket, or IPv4 one, at least in slow paths.

Ideally, we could save 8 bytes per struct sock_common, if we
alias skc_daddr & skc_rcv_saddr to skc_v6_daddr[3]/skc_v6_rcv_saddr[3].
====================

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

17 files changed, 110 insertions, 174 deletions

diff --git a/include/linux/udp.h b/include/linux/udp.h
index 247cfdcc4b08..87c094961bd5 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -34,7 +34,7 @@ static inline struct udphdr *inner_udp_hdr(const struct sk_buff *skb)
 
 #define UDP_HTABLE_SIZE_MIN             (CONFIG_BASE_SMALL ? 128 : 256)
 
-static inline int udp_hashfn(struct net *net, unsigned num, unsigned mask)
+static inline u32 udp_hashfn(const struct net *net, u32 num, u32 mask)
 {
         return (num + net_hash_mix(net)) & mask;
 }
diff --git a/include/net/inet6_hashtables.h b/include/net/inet6_hashtables.h
index 9201afe083fa..7ff588ca6817 100644
--- a/include/net/inet6_hashtables.h
+++ b/include/net/inet6_hashtables.h
@@ -38,8 +38,6 @@ static inline unsigned int __inet6_ehashfn(const u32 lhash,
         return jhash_3words(lhash, fhash, ports, initval);
 }
 
-int __inet6_hash(struct sock *sk, struct inet_timewait_sock *twp);
-
 /*
  * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index bcd64756e5fe..73fe0f9525d9 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -221,8 +221,8 @@ inet_bind_bucket_create(struct kmem_cache *cachep, struct net *net,
 void inet_bind_bucket_destroy(struct kmem_cache *cachep,
                               struct inet_bind_bucket *tb);
 
-static inline int inet_bhashfn(struct net *net, const __u16 lport,
-                               const int bhash_size)
+static inline u32 inet_bhashfn(const struct net *net, const __u16 lport,
+                               const u32 bhash_size)
 {
         return (lport + net_hash_mix(net)) & (bhash_size - 1);
 }
@@ -231,7 +231,7 @@ void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
                     const unsigned short snum);
 
 /* These can have wildcards, don't try too hard. */
-static inline int inet_lhashfn(struct net *net, const unsigned short num)
+static inline u32 inet_lhashfn(const struct net *net, const unsigned short num)
 {
         return (num + net_hash_mix(net)) & (INET_LHTABLE_SIZE - 1);
 }
@@ -249,6 +249,7 @@ void inet_put_port(struct sock *sk);
 void inet_hashinfo_init(struct inet_hashinfo *h);
 
 int __inet_hash_nolisten(struct sock *sk, struct inet_timewait_sock *tw);
+int __inet_hash(struct sock *sk, struct inet_timewait_sock *tw);
 void inet_hash(struct sock *sk);
 void inet_unhash(struct sock *sk);
 
@@ -383,13 +384,32 @@ static inline struct sock *__inet_lookup_skb(struct inet_hashinfo *hashinfo,
                                      iph->daddr, dport, inet_iif(skb));
 }
 
+u32 sk_ehashfn(const struct sock *sk);
+u32 inet6_ehashfn(const struct net *net,
+                  const struct in6_addr *laddr, const u16 lport,
+                  const struct in6_addr *faddr, const __be16 fport);
+
+static inline void sk_daddr_set(struct sock *sk, __be32 addr)
+{
+        sk->sk_daddr = addr; /* alias of inet_daddr */
+#if IS_ENABLED(CONFIG_IPV6)
+        ipv6_addr_set_v4mapped(addr, &sk->sk_v6_daddr);
+#endif
+}
+
+static inline void sk_rcv_saddr_set(struct sock *sk, __be32 addr)
+{
+        sk->sk_rcv_saddr = addr; /* alias of inet_rcv_saddr */
+#if IS_ENABLED(CONFIG_IPV6)
+        ipv6_addr_set_v4mapped(addr, &sk->sk_v6_rcv_saddr);
+#endif
+}
+
 int __inet_hash_connect(struct inet_timewait_death_row *death_row,
                         struct sock *sk, u32 port_offset,
                         int (*check_established)(struct inet_timewait_death_row *,
                                                  struct sock *, __u16,
-                                                 struct inet_timewait_sock **),
-                        int (*hash)(struct sock *sk,
-                                    struct inet_timewait_sock *twp));
+                                                 struct inet_timewait_sock **));
 
 int inet_hash_connect(struct inet_timewait_death_row *death_row,
                       struct sock *sk);
diff --git a/include/net/netns/hash.h b/include/net/netns/hash.h
index c06ac58ca107..69a6715d9f3f 100644
--- a/include/net/netns/hash.h
+++ b/include/net/netns/hash.h
@@ -5,7 +5,7 @@
 
 struct net;
 
-static inline unsigned int net_hash_mix(struct net *net)
+static inline u32 net_hash_mix(const struct net *net)
 {
 #ifdef CONFIG_NET_NS
         /*
@@ -13,7 +13,7 @@ static inline unsigned int net_hash_mix(struct net *net)
          * always zeroed
          */
 
-        return (unsigned)(((unsigned long)net) >> L1_CACHE_SHIFT);
+        return (u32)(((unsigned long)net) >> L1_CACHE_SHIFT);
 #else
         return 0;
 #endif
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 3fa4f824900a..e7ef86340514 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -91,6 +91,11 @@ static inline struct request_sock *inet_reqsk(struct sock *sk)
         return (struct request_sock *)sk;
 }
 
+static inline struct sock *req_to_sk(struct request_sock *req)
+{
+        return (struct sock *)req;
+}
+
 static inline void reqsk_free(struct request_sock *req)
 {
         /* temporary debugging */
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index bf897829f4f0..e7ad291cd96b 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -89,10 +89,9 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 
         if (inet->inet_saddr == 0)
                 inet->inet_saddr = fl4->saddr;
-        inet->inet_rcv_saddr = inet->inet_saddr;
-
+        sk_rcv_saddr_set(sk, inet->inet_saddr);
         inet->inet_dport = usin->sin_port;
-        inet->inet_daddr = daddr;
+        sk_daddr_set(sk, daddr);
 
         inet_csk(sk)->icsk_ext_hdr_len = 0;
         if (inet_opt)
@@ -408,8 +407,8 @@ struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb,
 
         newinet            = inet_sk(newsk);
         ireq               = inet_rsk(req);
-        newinet->inet_daddr     = ireq->ir_rmt_addr;
-        newinet->inet_rcv_saddr = ireq->ir_loc_addr;
+        sk_daddr_set(newsk, ireq->ir_rmt_addr);
+        sk_rcv_saddr_set(newsk, ireq->ir_loc_addr);
         newinet->inet_saddr     = ireq->ir_loc_addr;
         newinet->inet_opt       = ireq->opt;
         ireq->opt          = NULL;
@@ -639,8 +638,8 @@ int dccp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
                 goto drop_and_free;
 
         ireq = inet_rsk(req);
-        ireq->ir_loc_addr = ip_hdr(skb)->daddr;
-        ireq->ir_rmt_addr = ip_hdr(skb)->saddr;
+        sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
+        sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
         ireq->ireq_family = AF_INET;
         ireq->ir_iif = sk->sk_bound_dev_if;
 
diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
index d7e7c7b0a3f1..c655de5f67c9 100644
--- a/net/dccp/ipv6.c
+++ b/net/dccp/ipv6.c
@@ -40,19 +40,6 @@
 static const struct inet_connection_sock_af_ops dccp_ipv6_mapped;
 static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
 
-static void dccp_v6_hash(struct sock *sk)
-{
-        if (sk->sk_state != DCCP_CLOSED) {
-                if (inet_csk(sk)->icsk_af_ops == &dccp_ipv6_mapped) {
-                        inet_hash(sk);
-                        return;
-                }
-                local_bh_disable();
-                __inet6_hash(sk, NULL);
-                local_bh_enable();
-        }
-}
-
 /* add pseudo-header to DCCP checksum stored in skb->csum */
 static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
                                       const struct in6_addr *saddr,
@@ -470,11 +457,7 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
 
                 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 
-                ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
-
-                ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
-
-                newsk->sk_v6_rcv_saddr = newnp->saddr;
+                newnp->saddr = newsk->sk_v6_rcv_saddr;
 
                 inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
                 newsk->sk_backlog_rcv = dccp_v4_do_rcv;
@@ -592,7 +575,7 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
                 dccp_done(newsk);
                 goto out;
         }
-        __inet6_hash(newsk, NULL);
+        __inet_hash(newsk, NULL);
 
         return newsk;
 
@@ -917,9 +900,7 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
                         sk->sk_backlog_rcv = dccp_v6_do_rcv;
                         goto failure;
                 }
-                ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
-                ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &sk->sk_v6_rcv_saddr);
-
+                np->saddr = sk->sk_v6_rcv_saddr;
                 return err;
         }
 
@@ -1062,7 +1043,7 @@ static struct proto dccp_v6_prot = {
         .sendmsg           = dccp_sendmsg,
         .recvmsg           = dccp_recvmsg,
         .backlog_rcv       = dccp_v6_do_rcv,
-        .hash              = dccp_v6_hash,
+        .hash              = inet_hash,
         .unhash            = inet_unhash,
         .accept            = inet_csk_accept,
         .get_port          = inet_csk_get_port,
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 5105759e4e00..375dc71b9a64 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -107,7 +107,7 @@ static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
 
 static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
 
-static u32 inet_addr_hash(struct net *net, __be32 addr)
+static u32 inet_addr_hash(const struct net *net, __be32 addr)
 {
         u32 val = (__force u32) addr ^ net_hash_mix(net);
 
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index e7ba59038c8d..74c39c9f3e11 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -742,14 +742,14 @@ static int inet_diag_dump_reqs(struct sk_buff *skb, struct sock *sk,
 
                         if (bc) {
                                 /* Note: entry.sport and entry.userlocks are already set */
-                                entry_fill_addrs(&entry, (struct sock *)req);
+                                entry_fill_addrs(&entry, req_to_sk(req));
                                 entry.dport = ntohs(ireq->ir_rmt_port);
 
                                 if (!inet_diag_bc_run(bc, &entry))
                                         continue;
                         }
 
-                        err = inet_req_diag_fill((struct sock *)req, skb,
+                        err = inet_req_diag_fill(req_to_sk(req), skb,
                                                  NETLINK_CB(cb->skb).portid,
                                                  cb->nlh->nlmsg_seq,
                                                  NLM_F_MULTI, cb->nlh);
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index c28bca4cc15b..0fb841b9d834 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -24,9 +24,9 @@
 #include <net/secure_seq.h>
 #include <net/ip.h>
 
-static unsigned int inet_ehashfn(struct net *net, const __be32 laddr,
-                                 const __u16 lport, const __be32 faddr,
-                                 const __be16 fport)
+static u32 inet_ehashfn(const struct net *net, const __be32 laddr,
+                        const __u16 lport, const __be32 faddr,
+                        const __be16 fport)
 {
         static u32 inet_ehash_secret __read_mostly;
 
@@ -36,17 +36,21 @@ static unsigned int inet_ehashfn(struct net *net, const __be32 laddr,
                               inet_ehash_secret + net_hash_mix(net));
 }
 
-
-static unsigned int inet_sk_ehashfn(const struct sock *sk)
+/* This function handles inet_sock, but also timewait and request sockets
+ * for IPv4/IPv6.
+ */
+u32 sk_ehashfn(const struct sock *sk)
 {
-        const struct inet_sock *inet = inet_sk(sk);
-        const __be32 laddr = inet->inet_rcv_saddr;
-        const __u16 lport = inet->inet_num;
-        const __be32 faddr = inet->inet_daddr;
-        const __be16 fport = inet->inet_dport;
-        struct net *net = sock_net(sk);
-
-        return inet_ehashfn(net, laddr, lport, faddr, fport);
+#if IS_ENABLED(CONFIG_IPV6)
+        if (sk->sk_family == AF_INET6 &&
+            !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
+                return inet6_ehashfn(sock_net(sk),
+                                     &sk->sk_v6_rcv_saddr, sk->sk_num,
+                                     &sk->sk_v6_daddr, sk->sk_dport);
+#endif
+        return inet_ehashfn(sock_net(sk),
+                            sk->sk_rcv_saddr, sk->sk_num,
+                            sk->sk_daddr, sk->sk_dport);
 }
 
 /*
@@ -407,13 +411,13 @@ int __inet_hash_nolisten(struct sock *sk, struct inet_timewait_sock *tw)
 {
         struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
         struct hlist_nulls_head *list;
-        spinlock_t *lock;
         struct inet_ehash_bucket *head;
+        spinlock_t *lock;
         int twrefcnt = 0;
 
         WARN_ON(!sk_unhashed(sk));
 
-        sk->sk_hash = inet_sk_ehashfn(sk);
+        sk->sk_hash = sk_ehashfn(sk);
         head = inet_ehash_bucket(hashinfo, sk->sk_hash);
         list = &head->chain;
         lock = inet_ehash_lockp(hashinfo, sk->sk_hash);
@@ -430,15 +434,13 @@ int __inet_hash_nolisten(struct sock *sk, struct inet_timewait_sock *tw)
 }
 EXPORT_SYMBOL_GPL(__inet_hash_nolisten);
 
-static void __inet_hash(struct sock *sk)
+int __inet_hash(struct sock *sk, struct inet_timewait_sock *tw)
 {
         struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
         struct inet_listen_hashbucket *ilb;
 
-        if (sk->sk_state != TCP_LISTEN) {
-                __inet_hash_nolisten(sk, NULL);
-                return;
-        }
+        if (sk->sk_state != TCP_LISTEN)
+                return __inet_hash_nolisten(sk, tw);
 
         WARN_ON(!sk_unhashed(sk));
         ilb = &hashinfo->listening_hash[inet_sk_listen_hashfn(sk)];
@@ -447,13 +449,15 @@ static void __inet_hash(struct sock *sk)
         __sk_nulls_add_node_rcu(sk, &ilb->head);
         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
         spin_unlock(&ilb->lock);
+        return 0;
 }
+EXPORT_SYMBOL(__inet_hash);
 
 void inet_hash(struct sock *sk)
 {
         if (sk->sk_state != TCP_CLOSE) {
                 local_bh_disable();
-                __inet_hash(sk);
+                __inet_hash(sk, NULL);
                 local_bh_enable();
         }
 }
@@ -484,8 +488,7 @@ EXPORT_SYMBOL_GPL(inet_unhash);
 int __inet_hash_connect(struct inet_timewait_death_row *death_row,
                 struct sock *sk, u32 port_offset,
                 int (*check_established)(struct inet_timewait_death_row *,
-                        struct sock *, __u16, struct inet_timewait_sock **),
-                int (*hash)(struct sock *sk, struct inet_timewait_sock *twp))
+                        struct sock *, __u16, struct inet_timewait_sock **))
 {
         struct inet_hashinfo *hinfo = death_row->hashinfo;
         const unsigned short snum = inet_sk(sk)->inet_num;
@@ -555,7 +558,7 @@ ok:
                 inet_bind_hash(sk, tb, port);
                 if (sk_unhashed(sk)) {
                         inet_sk(sk)->inet_sport = htons(port);
-                        twrefcnt += hash(sk, tw);
+                        twrefcnt += __inet_hash_nolisten(sk, tw);
                 }
                 if (tw)
                         twrefcnt += inet_twsk_bind_unhash(tw, hinfo);
@@ -577,7 +580,7 @@ ok:
         tb  = inet_csk(sk)->icsk_bind_hash;
         spin_lock_bh(&head->lock);
         if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
-                hash(sk, NULL);
+                __inet_hash_nolisten(sk, NULL);
                 spin_unlock_bh(&head->lock);
                 return 0;
         } else {
@@ -597,7 +600,7 @@ int inet_hash_connect(struct inet_timewait_death_row *death_row,
                       struct sock *sk)
 {
         return __inet_hash_connect(death_row, sk, inet_sk_port_offset(sk),
-                        __inet_check_established, __inet_hash_nolisten);
+                                   __inet_check_established);
 }
 EXPORT_SYMBOL_GPL(inet_hash_connect);
 
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index fd88f868776f..344e7cdfb8d4 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -64,11 +64,11 @@ EXPORT_SYMBOL_GPL(pingv6_ops);
 
 static u16 ping_port_rover;
 
-static inline int ping_hashfn(struct net *net, unsigned int num, unsigned int mask)
+static inline u32 ping_hashfn(const struct net *net, u32 num, u32 mask)
 {
-        int res = (num + net_hash_mix(net)) & mask;
+        u32 res = (num + net_hash_mix(net)) & mask;
 
-        pr_debug("hash(%d) = %d\n", num, res);
+        pr_debug("hash(%u) = %u\n", num, res);
         return res;
 }
 EXPORT_SYMBOL_GPL(ping_hash);
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index 34e755403715..ef01d8570358 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -337,8 +337,8 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)
         req->mss                = mss;
         ireq->ir_num            = ntohs(th->dest);
         ireq->ir_rmt_port       = th->source;
-        ireq->ir_loc_addr       = ip_hdr(skb)->daddr;
-        ireq->ir_rmt_addr       = ip_hdr(skb)->saddr;
+        sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
+        sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
         ireq->ir_mark           = inet_request_mark(sk, skb);
         ireq->snd_wscale        = tcp_opt.snd_wscale;
         ireq->sack_ok           = tcp_opt.sack_ok;
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 80067d5858b4..ddd0b1f25b96 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -189,7 +189,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 
         if (!inet->inet_saddr)
                 inet->inet_saddr = fl4->saddr;
-        inet->inet_rcv_saddr = inet->inet_saddr;
+        sk_rcv_saddr_set(sk, inet->inet_saddr);
 
         if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
                 /* Reset inherited state */
@@ -204,7 +204,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
                 tcp_fetch_timewait_stamp(sk, &rt->dst);
 
         inet->inet_dport = usin->sin_port;
-        inet->inet_daddr = daddr;
+        sk_daddr_set(sk, daddr);
 
         inet_csk(sk)->icsk_ext_hdr_len = 0;
         if (inet_opt)
@@ -1219,14 +1219,14 @@ static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
 
 #endif
 
-static void tcp_v4_init_req(struct request_sock *req, struct sock *sk,
+static void tcp_v4_init_req(struct request_sock *req, struct sock *sk_listener,
                             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;
+        sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
+        sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
+        ireq->no_srccheck = inet_sk(sk_listener)->transparent;
         ireq->opt = tcp_v4_save_options(skb);
         ireq->ireq_family = AF_INET;
 }
@@ -1319,8 +1319,8 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
         newtp                 = tcp_sk(newsk);
         newinet               = inet_sk(newsk);
         ireq                  = inet_rsk(req);
-        newinet->inet_daddr   = ireq->ir_rmt_addr;
-        newinet->inet_rcv_saddr = ireq->ir_loc_addr;
+        sk_daddr_set(newsk, ireq->ir_rmt_addr);
+        sk_rcv_saddr_set(newsk, ireq->ir_loc_addr);
         newinet->inet_saddr           = ireq->ir_loc_addr;
         inet_opt              = ireq->opt;
         rcu_assign_pointer(newinet->inet_opt, inet_opt);
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index f27556e2158b..294af16633af 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -318,8 +318,8 @@ static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
                    inet1->inet_rcv_saddr == inet2->inet_rcv_saddr));
 }
 
-static unsigned int udp4_portaddr_hash(struct net *net, __be32 saddr,
-                                       unsigned int port)
+static u32 udp4_portaddr_hash(const struct net *net, __be32 saddr,
+                              unsigned int port)
 {
         return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
 }
@@ -421,9 +421,9 @@ static inline int compute_score2(struct sock *sk, struct net *net,
         return score;
 }
 
-static unsigned int udp_ehashfn(struct net *net, const __be32 laddr,
-                                 const __u16 lport, const __be32 faddr,
-                                 const __be16 fport)
+static u32 udp_ehashfn(const struct net *net, const __be32 laddr,
+                       const __u16 lport, const __be32 faddr,
+                       const __be16 fport)
 {
         static u32 udp_ehash_secret __read_mostly;
 
diff --git a/net/ipv6/inet6_hashtables.c b/net/ipv6/inet6_hashtables.c
index 051dffb49c90..033f17816ef4 100644
--- a/net/ipv6/inet6_hashtables.c
+++ b/net/ipv6/inet6_hashtables.c
@@ -23,11 +23,9 @@
 #include <net/secure_seq.h>
 #include <net/ip.h>
 
-static unsigned int inet6_ehashfn(struct net *net,
-                                  const struct in6_addr *laddr,
-                                  const u16 lport,
-                                  const struct in6_addr *faddr,
-                                  const __be16 fport)
+u32 inet6_ehashfn(const struct net *net,
+                  const struct in6_addr *laddr, const u16 lport,
+                  const struct in6_addr *faddr, const __be16 fport)
 {
         static u32 inet6_ehash_secret __read_mostly;
         static u32 ipv6_hash_secret __read_mostly;
@@ -44,54 +42,6 @@ static unsigned int inet6_ehashfn(struct net *net,
                                inet6_ehash_secret + net_hash_mix(net));
 }
 
-static int inet6_sk_ehashfn(const struct sock *sk)
-{
-        const struct inet_sock *inet = inet_sk(sk);
-        const struct in6_addr *laddr = &sk->sk_v6_rcv_saddr;
-        const struct in6_addr *faddr = &sk->sk_v6_daddr;
-        const __u16 lport = inet->inet_num;
-        const __be16 fport = inet->inet_dport;
-        struct net *net = sock_net(sk);
-
-        return inet6_ehashfn(net, laddr, lport, faddr, fport);
-}
-
-int __inet6_hash(struct sock *sk, struct inet_timewait_sock *tw)
-{
-        struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
-        int twrefcnt = 0;
-
-        WARN_ON(!sk_unhashed(sk));
-
-        if (sk->sk_state == TCP_LISTEN) {
-                struct inet_listen_hashbucket *ilb;
-
-                ilb = &hashinfo->listening_hash[inet_sk_listen_hashfn(sk)];
-                spin_lock(&ilb->lock);
-                __sk_nulls_add_node_rcu(sk, &ilb->head);
-                spin_unlock(&ilb->lock);
-        } else {
-                unsigned int hash;
-                struct hlist_nulls_head *list;
-                spinlock_t *lock;
-
-                sk->sk_hash = hash = inet6_sk_ehashfn(sk);
-                list = &inet_ehash_bucket(hashinfo, hash)->chain;
-                lock = inet_ehash_lockp(hashinfo, hash);
-                spin_lock(lock);
-                __sk_nulls_add_node_rcu(sk, list);
-                if (tw) {
-                        WARN_ON(sk->sk_hash != tw->tw_hash);
-                        twrefcnt = inet_twsk_unhash(tw);
-                }
-                spin_unlock(lock);
-        }
-
-        sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
-        return twrefcnt;
-}
-EXPORT_SYMBOL(__inet6_hash);
-
 /*
  * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
@@ -320,6 +270,6 @@ int inet6_hash_connect(struct inet_timewait_death_row *death_row,
                        struct sock *sk)
 {
         return __inet_hash_connect(death_row, sk, inet6_sk_port_offset(sk),
-                        __inet6_check_established, __inet6_hash);
+                                   __inet6_check_established);
 }
 EXPORT_SYMBOL_GPL(inet6_hash_connect);
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index e4761b22307b..720676d073d9 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -104,19 +104,6 @@ static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
         }
 }
 
-static void tcp_v6_hash(struct sock *sk)
-{
-        if (sk->sk_state != TCP_CLOSE) {
-                if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
-                        tcp_prot.hash(sk);
-                        return;
-                }
-                local_bh_disable();
-                __inet6_hash(sk, NULL);
-                local_bh_enable();
-        }
-}
-
 static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
 {
         return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
@@ -233,11 +220,8 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
                         tp->af_specific = &tcp_sock_ipv6_specific;
 #endif
                         goto failure;
-                } else {
-                        ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
-                        ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
-                                               &sk->sk_v6_rcv_saddr);
                 }
+                np->saddr = sk->sk_v6_rcv_saddr;
 
                 return err;
         }
@@ -1078,11 +1062,7 @@ static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
 
                 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 
-                ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
-
-                ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
-
-                newsk->sk_v6_rcv_saddr = newnp->saddr;
+                newnp->saddr = newsk->sk_v6_rcv_saddr;
 
                 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
                 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
@@ -1231,7 +1211,7 @@ static struct sock *tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
                 tcp_done(newsk);
                 goto out;
         }
-        __inet6_hash(newsk, NULL);
+        __inet_hash(newsk, NULL);
 
         return newsk;
 
@@ -1890,7 +1870,7 @@ struct proto tcpv6_prot = {
         .sendpage               = tcp_sendpage,
         .backlog_rcv            = tcp_v6_do_rcv,
         .release_cb             = tcp_release_cb,
-        .hash                   = tcp_v6_hash,
+        .hash                   = inet_hash,
         .unhash                 = inet_unhash,
         .get_port               = inet_csk_get_port,
         .enter_memory_pressure  = tcp_enter_memory_pressure,
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 70568a4548e4..7fe0329c0d37 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -53,11 +53,11 @@
 #include <trace/events/skb.h>
 #include "udp_impl.h"
 
-static unsigned int udp6_ehashfn(struct net *net,
-                                  const struct in6_addr *laddr,
-                                  const u16 lport,
-                                  const struct in6_addr *faddr,
-                                  const __be16 fport)
+static u32 udp6_ehashfn(const struct net *net,
+                        const struct in6_addr *laddr,
+                        const u16 lport,
+                        const struct in6_addr *faddr,
+                        const __be16 fport)
 {
         static u32 udp6_ehash_secret __read_mostly;
         static u32 udp_ipv6_hash_secret __read_mostly;
@@ -104,9 +104,9 @@ int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
         return 0;
 }
 
-static unsigned int udp6_portaddr_hash(struct net *net,
-                                       const struct in6_addr *addr6,
-                                       unsigned int port)
+static u32 udp6_portaddr_hash(const struct net *net,
+                              const struct in6_addr *addr6,
+                              unsigned int port)
 {
         unsigned int hash, mix = net_hash_mix(net);