inet: includes a sock_common in request_sock

TCP listener refactoring, part 5 :

We want to be able to insert request sockets (SYN_RECV) into main
ehash table instead of the per listener hash table to allow RCU
lookups and remove listener lock contention.

This patch includes the needed struct sock_common in front
of struct request_sock

This means there is no more inet6_request_sock IPv6 specific
structure.

Following inet_request_sock fields were renamed as they became
macros to reference fields from struct sock_common.
Prefix ir_ was chosen to avoid name collisions.

loc_port   -> ir_loc_port
loc_addr   -> ir_loc_addr
rmt_addr   -> ir_rmt_addr
rmt_port   -> ir_rmt_port
iif        -> ir_iif

Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 55 insertions, 52 deletions

diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 56e82a4027b4..2ffd931d652f 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -412,8 +412,8 @@ struct dst_entry *inet_csk_route_req(struct sock *sk,
                            RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
                            sk->sk_protocol,
                            flags,
-                           (opt && opt->opt.srr) ? opt->opt.faddr : ireq->rmt_addr,
-                           ireq->loc_addr, ireq->rmt_port, inet_sk(sk)->inet_sport);
+                           (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
+                           ireq->ir_loc_addr, ireq->ir_rmt_port, inet_sk(sk)->inet_sport);
         security_req_classify_flow(req, flowi4_to_flowi(fl4));
         rt = ip_route_output_flow(net, fl4, sk);
         if (IS_ERR(rt))
@@ -448,8 +448,8 @@ struct dst_entry *inet_csk_route_child_sock(struct sock *sk,
         flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
                            RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
                            sk->sk_protocol, inet_sk_flowi_flags(sk),
-                           (opt && opt->opt.srr) ? opt->opt.faddr : ireq->rmt_addr,
-                           ireq->loc_addr, ireq->rmt_port, inet_sk(sk)->inet_sport);
+                           (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
+                           ireq->ir_loc_addr, ireq->ir_rmt_port, inet_sk(sk)->inet_sport);
         security_req_classify_flow(req, flowi4_to_flowi(fl4));
         rt = ip_route_output_flow(net, fl4, sk);
         if (IS_ERR(rt))
@@ -495,9 +495,9 @@ struct request_sock *inet_csk_search_req(const struct sock *sk,
              prev = &req->dl_next) {
                 const struct inet_request_sock *ireq = inet_rsk(req);
 
-                if (ireq->rmt_port == rport &&
-                    ireq->rmt_addr == raddr &&
-                    ireq->loc_addr == laddr &&
+                if (ireq->ir_rmt_port == rport &&
+                    ireq->ir_rmt_addr == raddr &&
+                    ireq->ir_loc_addr == laddr &&
                     AF_INET_FAMILY(req->rsk_ops->family)) {
                         WARN_ON(req->sk);
                         *prevp = prev;
@@ -514,7 +514,8 @@ void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req,
 {
         struct inet_connection_sock *icsk = inet_csk(sk);
         struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
-        const u32 h = inet_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port,
+        const u32 h = inet_synq_hash(inet_rsk(req)->ir_rmt_addr,
+                                     inet_rsk(req)->ir_rmt_port,
                                      lopt->hash_rnd, lopt->nr_table_entries);
 
         reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, timeout);
@@ -674,9 +675,9 @@ struct sock *inet_csk_clone_lock(const struct sock *sk,
                 newsk->sk_state = TCP_SYN_RECV;
                 newicsk->icsk_bind_hash = NULL;
 
-                inet_sk(newsk)->inet_dport = inet_rsk(req)->rmt_port;
-                inet_sk(newsk)->inet_num = ntohs(inet_rsk(req)->loc_port);
-                inet_sk(newsk)->inet_sport = inet_rsk(req)->loc_port;
+                inet_sk(newsk)->inet_dport = inet_rsk(req)->ir_rmt_port;
+                inet_sk(newsk)->inet_num = ntohs(inet_rsk(req)->ir_loc_port);
+                inet_sk(newsk)->inet_sport = inet_rsk(req)->ir_loc_port;
                 newsk->sk_write_space = sk_stream_write_space;
 
                 newicsk->icsk_retransmits = 0;
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index ecc179d676e4..41e1c3ea8b51 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -679,12 +679,12 @@ static inline void inet_diag_req_addrs(const struct sock *sk,
 #if IS_ENABLED(CONFIG_IPV6)
         if (sk->sk_family == AF_INET6) {
                 if (req->rsk_ops->family == AF_INET6) {
-                        entry->saddr = inet6_rsk(req)->loc_addr.s6_addr32;
-                        entry->daddr = inet6_rsk(req)->rmt_addr.s6_addr32;
+                        entry->saddr = ireq->ir_v6_loc_addr.s6_addr32;
+                        entry->daddr = ireq->ir_v6_rmt_addr.s6_addr32;
                 } else if (req->rsk_ops->family == AF_INET) {
-                        ipv6_addr_set_v4mapped(ireq->loc_addr,
+                        ipv6_addr_set_v4mapped(ireq->ir_loc_addr,
                                                &entry->saddr_storage);
-                        ipv6_addr_set_v4mapped(ireq->rmt_addr,
+                        ipv6_addr_set_v4mapped(ireq->ir_rmt_addr,
                                                &entry->daddr_storage);
                         entry->saddr = entry->saddr_storage.s6_addr32;
                         entry->daddr = entry->daddr_storage.s6_addr32;
@@ -692,8 +692,8 @@ static inline void inet_diag_req_addrs(const struct sock *sk,
         } else
 #endif
         {
-                entry->saddr = &ireq->loc_addr;
-                entry->daddr = &ireq->rmt_addr;
+                entry->saddr = &ireq->ir_loc_addr;
+                entry->daddr = &ireq->ir_rmt_addr;
         }
 }
 
@@ -728,9 +728,9 @@ static int inet_diag_fill_req(struct sk_buff *skb, struct sock *sk,
                 tmo = 0;
 
         r->id.idiag_sport = inet->inet_sport;
-        r->id.idiag_dport = ireq->rmt_port;
-        r->id.idiag_src[0] = ireq->loc_addr;
-        r->id.idiag_dst[0] = ireq->rmt_addr;
+        r->id.idiag_dport = ireq->ir_rmt_port;
+        r->id.idiag_src[0] = ireq->ir_loc_addr;
+        r->id.idiag_dst[0] = ireq->ir_rmt_addr;
         r->idiag_expires = jiffies_to_msecs(tmo);
         r->idiag_rqueue = 0;
         r->idiag_wqueue = 0;
@@ -789,13 +789,13 @@ static int inet_diag_dump_reqs(struct sk_buff *skb, struct sock *sk,
 
                         if (reqnum < s_reqnum)
                                 continue;
-                        if (r->id.idiag_dport != ireq->rmt_port &&
+                        if (r->id.idiag_dport != ireq->ir_rmt_port &&
                             r->id.idiag_dport)
                                 continue;
 
                         if (bc) {
                                 inet_diag_req_addrs(sk, req, &entry);
-                                entry.dport = ntohs(ireq->rmt_port);
+                                entry.dport = ntohs(ireq->ir_rmt_port);
 
                                 if (!inet_diag_bc_run(bc, &entry))
                                         continue;
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index 15e024105f91..984e21cf3c50 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -304,10 +304,10 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         treq->rcv_isn           = ntohl(th->seq) - 1;
         treq->snt_isn           = cookie;
         req->mss                = mss;
-        ireq->loc_port          = th->dest;
-        ireq->rmt_port          = th->source;
-        ireq->loc_addr          = ip_hdr(skb)->daddr;
-        ireq->rmt_addr          = ip_hdr(skb)->saddr;
+        ireq->ir_loc_port               = th->dest;
+        ireq->ir_rmt_port               = th->source;
+        ireq->ir_loc_addr               = ip_hdr(skb)->daddr;
+        ireq->ir_rmt_addr               = ip_hdr(skb)->saddr;
         ireq->ecn_ok            = ecn_ok;
         ireq->snd_wscale        = tcp_opt.snd_wscale;
         ireq->sack_ok           = tcp_opt.sack_ok;
@@ -347,8 +347,8 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
         flowi4_init_output(&fl4, sk->sk_bound_dev_if, sk->sk_mark,
                            RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE, IPPROTO_TCP,
                            inet_sk_flowi_flags(sk),
-                           (opt && opt->srr) ? opt->faddr : ireq->rmt_addr,
-                           ireq->loc_addr, th->source, th->dest);
+                           (opt && opt->srr) ? opt->faddr : ireq->ir_rmt_addr,
+                           ireq->ir_loc_addr, th->source, th->dest);
         security_req_classify_flow(req, flowi4_to_flowi(&fl4));
         rt = ip_route_output_key(sock_net(sk), &fl4);
         if (IS_ERR(rt)) {
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index e4695dde1af6..114d1b748cbb 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -835,11 +835,11 @@ static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
         skb = tcp_make_synack(sk, dst, req, NULL);
 
         if (skb) {
-                __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
+                __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
 
                 skb_set_queue_mapping(skb, queue_mapping);
-                err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
-                                            ireq->rmt_addr,
+                err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
+                                            ireq->ir_rmt_addr,
                                             ireq->opt);
                 err = net_xmit_eval(err);
                 if (!tcp_rsk(req)->snt_synack && !err)
@@ -972,7 +972,7 @@ static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
 {
         union tcp_md5_addr *addr;
 
-        addr = (union tcp_md5_addr *)&inet_rsk(req)->rmt_addr;
+        addr = (union tcp_md5_addr *)&inet_rsk(req)->ir_rmt_addr;
         return tcp_md5_do_lookup(sk, addr, AF_INET);
 }
 
@@ -1149,8 +1149,8 @@ int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
                 saddr = inet_sk(sk)->inet_saddr;
                 daddr = inet_sk(sk)->inet_daddr;
         } else if (req) {
-                saddr = inet_rsk(req)->loc_addr;
-                daddr = inet_rsk(req)->rmt_addr;
+                saddr = inet_rsk(req)->ir_loc_addr;
+                daddr = inet_rsk(req)->ir_rmt_addr;
         } else {
                 const struct iphdr *iph = ip_hdr(skb);
                 saddr = iph->saddr;
@@ -1366,8 +1366,8 @@ static int tcp_v4_conn_req_fastopen(struct sock *sk,
                 kfree_skb(skb_synack);
                 return -1;
         }
-        err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
-                                    ireq->rmt_addr, ireq->opt);
+        err = ip_build_and_send_pkt(skb_synack, sk, ireq->ir_loc_addr,
+                                    ireq->ir_rmt_addr, ireq->opt);
         err = net_xmit_eval(err);
         if (!err)
                 tcp_rsk(req)->snt_synack = tcp_time_stamp;
@@ -1502,8 +1502,8 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
         tcp_openreq_init(req, &tmp_opt, skb);
 
         ireq = inet_rsk(req);
-        ireq->loc_addr = daddr;
-        ireq->rmt_addr = saddr;
+        ireq->ir_loc_addr = daddr;
+        ireq->ir_rmt_addr = saddr;
         ireq->no_srccheck = inet_sk(sk)->transparent;
         ireq->opt = tcp_v4_save_options(skb);
 
@@ -1578,15 +1578,15 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
             fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);
 
         if (skb_synack) {
-                __tcp_v4_send_check(skb_synack, ireq->loc_addr, ireq->rmt_addr);
+                __tcp_v4_send_check(skb_synack, ireq->ir_loc_addr, ireq->ir_rmt_addr);
                 skb_set_queue_mapping(skb_synack, skb_get_queue_mapping(skb));
         } else
                 goto drop_and_free;
 
         if (likely(!do_fastopen)) {
                 int err;
-                err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
-                     ireq->rmt_addr, ireq->opt);
+                err = ip_build_and_send_pkt(skb_synack, sk, ireq->ir_loc_addr,
+                     ireq->ir_rmt_addr, ireq->opt);
                 err = net_xmit_eval(err);
                 if (err || want_cookie)
                         goto drop_and_free;
@@ -1644,9 +1644,9 @@ 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->rmt_addr;
-        newinet->inet_rcv_saddr = ireq->loc_addr;
-        newinet->inet_saddr           = ireq->loc_addr;
+        newinet->inet_daddr   = ireq->ir_rmt_addr;
+        newinet->inet_rcv_saddr = ireq->ir_loc_addr;
+        newinet->inet_saddr           = ireq->ir_loc_addr;
         inet_opt              = ireq->opt;
         rcu_assign_pointer(newinet->inet_opt, inet_opt);
         ireq->opt             = NULL;
@@ -2548,10 +2548,10 @@ static void get_openreq4(const struct sock *sk, const struct request_sock *req,
         seq_printf(f, "%4d: %08X:%04X %08X:%04X"
                 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK%n",
                 i,
-                ireq->loc_addr,
+                ireq->ir_loc_addr,
                 ntohs(inet_sk(sk)->inet_sport),
-                ireq->rmt_addr,
-                ntohs(ireq->rmt_port),
+                ireq->ir_rmt_addr,
+                ntohs(ireq->ir_rmt_port),
                 TCP_SYN_RECV,
                 0, 0, /* could print option size, but that is af dependent. */
                 1,    /* timers active (only the expire timer) */
diff --git a/net/ipv4/tcp_metrics.c b/net/ipv4/tcp_metrics.c
index 8fcc2cb9dba4..4a2a84110dfb 100644
--- a/net/ipv4/tcp_metrics.c
+++ b/net/ipv4/tcp_metrics.c
@@ -215,13 +215,15 @@ static struct tcp_metrics_block *__tcp_get_metrics_req(struct request_sock *req,
         addr.family = req->rsk_ops->family;
         switch (addr.family) {
         case AF_INET:
-                addr.addr.a4 = inet_rsk(req)->rmt_addr;
+                addr.addr.a4 = inet_rsk(req)->ir_rmt_addr;
                 hash = (__force unsigned int) addr.addr.a4;
                 break;
+#if IS_ENABLED(CONFIG_IPV6)
         case AF_INET6:
-                *(struct in6_addr *)addr.addr.a6 = inet6_rsk(req)->rmt_addr;
-                hash = ipv6_addr_hash(&inet6_rsk(req)->rmt_addr);
+                *(struct in6_addr *)addr.addr.a6 = inet_rsk(req)->ir_v6_rmt_addr;
+                hash = ipv6_addr_hash(&inet_rsk(req)->ir_v6_rmt_addr);
                 break;
+#endif
         default:
                 return NULL;
         }
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index c6f01f2cdb32..faec81353522 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2734,8 +2734,8 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         th->syn = 1;
         th->ack = 1;
         TCP_ECN_make_synack(req, th);
-        th->source = ireq->loc_port;
-        th->dest = ireq->rmt_port;
+        th->source = ireq->ir_loc_port;
+        th->dest = ireq->ir_rmt_port;
         /* Setting of flags are superfluous here for callers (and ECE is
          * not even correctly set)
          */