rds: Remove IPv6 dependency

This patch removes the IPv6 dependency from RDS.

Signed-off-by: Ka-Cheong Poon <ka-cheong.poon@oracle.com>
Acked-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

12 files changed, 140 insertions, 26 deletions

diff --git a/net/rds/Kconfig b/net/rds/Kconfig
index 4c7f2595d919..41f75563b54b 100644
--- a/net/rds/Kconfig
+++ b/net/rds/Kconfig
@@ -1,7 +1,7 @@
 
 config RDS
         tristate "The RDS Protocol"
-        depends on INET && IPV6
+        depends on INET
         ---help---
           The RDS (Reliable Datagram Sockets) protocol provides reliable,
           sequenced delivery of datagrams over Infiniband or TCP.
diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c
index fc5c48b248fe..65387e1e6964 100644
--- a/net/rds/af_rds.c
+++ b/net/rds/af_rds.c
@@ -156,18 +156,20 @@ static int rds_getname(struct socket *sock, struct sockaddr *uaddr,
                                 return sizeof(*sin);
                         }
 
-                        if (ipv6_addr_type(&rs->rs_conn_addr) &
-                            IPV6_ADDR_MAPPED) {
-                                sin = (struct sockaddr_in *)uaddr;
-                                memset(sin, 0, sizeof(*sin));
-                                sin->sin_family = AF_INET;
-                                return sizeof(*sin);
+#if IS_ENABLED(CONFIG_IPV6)
+                        if (!(ipv6_addr_type(&rs->rs_conn_addr) &
+                              IPV6_ADDR_MAPPED)) {
+                                sin6 = (struct sockaddr_in6 *)uaddr;
+                                memset(sin6, 0, sizeof(*sin6));
+                                sin6->sin6_family = AF_INET6;
+                                return sizeof(*sin6);
                         }
+#endif
 
-                        sin6 = (struct sockaddr_in6 *)uaddr;
-                        memset(sin6, 0, sizeof(*sin6));
-                        sin6->sin6_family = AF_INET6;
-                        return sizeof(*sin6);
+                        sin = (struct sockaddr_in *)uaddr;
+                        memset(sin, 0, sizeof(*sin));
+                        sin->sin_family = AF_INET;
+                        return sizeof(*sin);
                 }
                 if (ipv6_addr_v4mapped(&rs->rs_bound_addr)) {
                         sin = (struct sockaddr_in *)uaddr;
@@ -501,9 +503,7 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
 {
         struct sock *sk = sock->sk;
         struct sockaddr_in *sin;
-        struct sockaddr_in6 *sin6;
         struct rds_sock *rs = rds_sk_to_rs(sk);
-        int addr_type;
         int ret = 0;
 
         lock_sock(sk);
@@ -528,7 +528,11 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
                 rs->rs_conn_port = sin->sin_port;
                 break;
 
-        case AF_INET6:
+#if IS_ENABLED(CONFIG_IPV6)
+        case AF_INET6: {
+                struct sockaddr_in6 *sin6;
+                int addr_type;
+
                 sin6 = (struct sockaddr_in6 *)uaddr;
                 if (addr_len < sizeof(struct sockaddr_in6)) {
                         ret = -EINVAL;
@@ -575,6 +579,8 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
                 rs->rs_conn_addr = sin6->sin6_addr;
                 rs->rs_conn_port = sin6->sin6_port;
                 break;
+        }
+#endif
 
         default:
                 ret = -EAFNOSUPPORT;
diff --git a/net/rds/bind.c b/net/rds/bind.c
index ba778760cbc2..3ab55784b637 100644
--- a/net/rds/bind.c
+++ b/net/rds/bind.c
@@ -165,7 +165,6 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         struct in6_addr v6addr, *binding_addr;
         struct rds_transport *trans;
         __u32 scope_id = 0;
-        int addr_type;
         int ret = 0;
         __be16 port;
 
@@ -183,8 +182,10 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &v6addr);
                 binding_addr = &v6addr;
                 port = sin->sin_port;
+#if IS_ENABLED(CONFIG_IPV6)
         } else if (uaddr->sa_family == AF_INET6) {
                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)uaddr;
+                int addr_type;
 
                 if (addr_len < sizeof(struct sockaddr_in6))
                         return -EINVAL;
@@ -212,6 +213,7 @@ int rds_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                 }
                 binding_addr = &sin6->sin6_addr;
                 port = sin6->sin6_port;
+#endif
         } else {
                 return -EINVAL;
         }
diff --git a/net/rds/connection.c b/net/rds/connection.c
index 051e35c1e7c6..3bd2f4a5a30d 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -63,8 +63,12 @@ static struct hlist_head *rds_conn_bucket(const struct in6_addr *laddr,
         net_get_random_once(&rds6_hash_secret, sizeof(rds6_hash_secret));
 
         lhash = (__force u32)laddr->s6_addr32[3];
+#if IS_ENABLED(CONFIG_IPV6)
         fhash = __ipv6_addr_jhash(faddr, rds6_hash_secret);
-        hash = __inet6_ehashfn(lhash, 0, fhash, 0, rds_hash_secret);
+#else
+        fhash = (__force u32)faddr->s6_addr32[3];
+#endif
+        hash = __inet_ehashfn(lhash, 0, fhash, 0, rds_hash_secret);
 
         return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK];
 }
@@ -201,6 +205,8 @@ static struct rds_connection *__rds_conn_create(struct net *net,
         conn->c_isv6 = !ipv6_addr_v4mapped(laddr);
         conn->c_faddr = *faddr;
         conn->c_dev_if = dev_if;
+
+#if IS_ENABLED(CONFIG_IPV6)
         /* If the local address is link local, set c_bound_if to be the
          * index used for this connection.  Otherwise, set it to 0 as
          * the socket is not bound to an interface.  c_bound_if is used
@@ -209,6 +215,7 @@ static struct rds_connection *__rds_conn_create(struct net *net,
         if (ipv6_addr_type(laddr) & IPV6_ADDR_LINKLOCAL)
                 conn->c_bound_if = dev_if;
         else
+#endif
                 conn->c_bound_if = 0;
 
         rds_conn_net_set(conn, net);
@@ -500,9 +507,11 @@ static void __rds_inc_msg_cp(struct rds_incoming *inc,
                              struct rds_info_iterator *iter,
                              void *saddr, void *daddr, int flip, bool isv6)
 {
+#if IS_ENABLED(CONFIG_IPV6)
         if (isv6)
                 rds6_inc_info_copy(inc, iter, saddr, daddr, flip);
         else
+#endif
                 rds_inc_info_copy(inc, iter, *(__be32 *)saddr,
                                   *(__be32 *)daddr, flip);
 }
@@ -581,6 +590,7 @@ static void rds_conn_message_info(struct socket *sock, unsigned int len,
         rds_conn_message_info_cmn(sock, len, iter, lens, want_send, false);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static void rds6_conn_message_info(struct socket *sock, unsigned int len,
                                    struct rds_info_iterator *iter,
                                    struct rds_info_lengths *lens,
@@ -588,6 +598,7 @@ static void rds6_conn_message_info(struct socket *sock, unsigned int len,
 {
         rds_conn_message_info_cmn(sock, len, iter, lens, want_send, true);
 }
+#endif
 
 static void rds_conn_message_info_send(struct socket *sock, unsigned int len,
                                        struct rds_info_iterator *iter,
@@ -596,12 +607,14 @@ static void rds_conn_message_info_send(struct socket *sock, unsigned int len,
         rds_conn_message_info(sock, len, iter, lens, 1);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static void rds6_conn_message_info_send(struct socket *sock, unsigned int len,
                                         struct rds_info_iterator *iter,
                                         struct rds_info_lengths *lens)
 {
         rds6_conn_message_info(sock, len, iter, lens, 1);
 }
+#endif
 
 static void rds_conn_message_info_retrans(struct socket *sock,
                                           unsigned int len,
@@ -611,6 +624,7 @@ static void rds_conn_message_info_retrans(struct socket *sock,
         rds_conn_message_info(sock, len, iter, lens, 0);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static void rds6_conn_message_info_retrans(struct socket *sock,
                                            unsigned int len,
                                            struct rds_info_iterator *iter,
@@ -618,6 +632,7 @@ static void rds6_conn_message_info_retrans(struct socket *sock,
 {
         rds6_conn_message_info(sock, len, iter, lens, 0);
 }
+#endif
 
 void rds_for_each_conn_info(struct socket *sock, unsigned int len,
                           struct rds_info_iterator *iter,
@@ -734,6 +749,7 @@ static int rds_conn_info_visitor(struct rds_conn_path *cp, void *buffer)
         return 1;
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer)
 {
         struct rds6_info_connection *cinfo6 = buffer;
@@ -761,6 +777,7 @@ static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer)
          */
         return 1;
 }
+#endif
 
 static void rds_conn_info(struct socket *sock, unsigned int len,
                           struct rds_info_iterator *iter,
@@ -774,6 +791,7 @@ static void rds_conn_info(struct socket *sock, unsigned int len,
                                 sizeof(struct rds_info_connection));
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 static void rds6_conn_info(struct socket *sock, unsigned int len,
                            struct rds_info_iterator *iter,
                            struct rds_info_lengths *lens)
@@ -785,6 +803,7 @@ static void rds6_conn_info(struct socket *sock, unsigned int len,
                                 buffer,
                                 sizeof(struct rds6_info_connection));
 }
+#endif
 
 int rds_conn_init(void)
 {
@@ -807,12 +826,13 @@ int rds_conn_init(void)
                                rds_conn_message_info_send);
         rds_info_register_func(RDS_INFO_RETRANS_MESSAGES,
                                rds_conn_message_info_retrans);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_register_func(RDS6_INFO_CONNECTIONS, rds6_conn_info);
         rds_info_register_func(RDS6_INFO_SEND_MESSAGES,
                                rds6_conn_message_info_send);
         rds_info_register_func(RDS6_INFO_RETRANS_MESSAGES,
                                rds6_conn_message_info_retrans);
-
+#endif
         return 0;
 }
 
@@ -830,11 +850,13 @@ void rds_conn_exit(void)
                                  rds_conn_message_info_send);
         rds_info_deregister_func(RDS_INFO_RETRANS_MESSAGES,
                                  rds_conn_message_info_retrans);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_deregister_func(RDS6_INFO_CONNECTIONS, rds6_conn_info);
         rds_info_deregister_func(RDS6_INFO_SEND_MESSAGES,
                                  rds6_conn_message_info_send);
         rds_info_deregister_func(RDS6_INFO_RETRANS_MESSAGES,
                                  rds6_conn_message_info_retrans);
+#endif
 }
 
 /*
diff --git a/net/rds/ib.c b/net/rds/ib.c
index a4245c42d43b..89c6333ecd39 100644
--- a/net/rds/ib.c
+++ b/net/rds/ib.c
@@ -321,6 +321,7 @@ static int rds_ib_conn_info_visitor(struct rds_connection *conn,
         return 1;
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 /* IPv6 version of rds_ib_conn_info_visitor(). */
 static int rds6_ib_conn_info_visitor(struct rds_connection *conn,
                                      void *buffer)
@@ -357,6 +358,7 @@ static int rds6_ib_conn_info_visitor(struct rds_connection *conn,
         }
         return 1;
 }
+#endif
 
 static void rds_ib_ic_info(struct socket *sock, unsigned int len,
                            struct rds_info_iterator *iter,
@@ -370,6 +372,7 @@ static void rds_ib_ic_info(struct socket *sock, unsigned int len,
                                 sizeof(struct rds_info_rdma_connection));
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 /* IPv6 version of rds_ib_ic_info(). */
 static void rds6_ib_ic_info(struct socket *sock, unsigned int len,
                             struct rds_info_iterator *iter,
@@ -382,6 +385,7 @@ static void rds6_ib_ic_info(struct socket *sock, unsigned int len,
                                buffer,
                                sizeof(struct rds6_info_rdma_connection));
 }
+#endif
 
 /*
  * Early RDS/IB was built to only bind to an address if there is an IPoIB
@@ -398,7 +402,9 @@ static int rds_ib_laddr_check(struct net *net, const struct in6_addr *addr,
 {
         int ret;
         struct rdma_cm_id *cm_id;
+#if IS_ENABLED(CONFIG_IPV6)
         struct sockaddr_in6 sin6;
+#endif
         struct sockaddr_in sin;
         struct sockaddr *sa;
         bool isv4;
@@ -418,6 +424,7 @@ static int rds_ib_laddr_check(struct net *net, const struct in6_addr *addr,
                 sin.sin_addr.s_addr = addr->s6_addr32[3];
                 sa = (struct sockaddr *)&sin;
         } else {
+#if IS_ENABLED(CONFIG_IPV6)
                 memset(&sin6, 0, sizeof(sin6));
                 sin6.sin6_family = AF_INET6;
                 sin6.sin6_addr = *addr;
@@ -432,21 +439,30 @@ static int rds_ib_laddr_check(struct net *net, const struct in6_addr *addr,
                 if (ipv6_addr_type(addr) & IPV6_ADDR_LINKLOCAL) {
                         struct net_device *dev;
 
-                        if (scope_id == 0)
-                                return -EADDRNOTAVAIL;
+                        if (scope_id == 0) {
+                                ret = -EADDRNOTAVAIL;
+                                goto out;
+                        }
 
                         /* Use init_net for now as RDS is not network
                          * name space aware.
                          */
                         dev = dev_get_by_index(&init_net, scope_id);
-                        if (!dev)
-                                return -EADDRNOTAVAIL;
+                        if (!dev) {
+                                ret = -EADDRNOTAVAIL;
+                                goto out;
+                        }
                         if (!ipv6_chk_addr(&init_net, addr, dev, 1)) {
                                 dev_put(dev);
-                                return -EADDRNOTAVAIL;
+                                ret = -EADDRNOTAVAIL;
+                                goto out;
                         }
                         dev_put(dev);
                 }
+#else
+                ret = -EADDRNOTAVAIL;
+                goto out;
+#endif
         }
 
         /* rdma_bind_addr will only succeed for IB & iWARP devices */
@@ -461,6 +477,7 @@ static int rds_ib_laddr_check(struct net *net, const struct in6_addr *addr,
                  addr, scope_id, ret,
                  cm_id->device ? cm_id->device->node_type : -1);
 
+out:
         rdma_destroy_id(cm_id);
 
         return ret;
@@ -491,7 +508,9 @@ void rds_ib_exit(void)
         rds_ib_set_unloading();
         synchronize_rcu();
         rds_info_deregister_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_deregister_func(RDS6_INFO_IB_CONNECTIONS, rds6_ib_ic_info);
+#endif
         rds_ib_unregister_client();
         rds_ib_destroy_nodev_conns();
         rds_ib_sysctl_exit();
@@ -553,7 +572,9 @@ int rds_ib_init(void)
         rds_trans_register(&rds_ib_transport);
 
         rds_info_register_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_register_func(RDS6_INFO_IB_CONNECTIONS, rds6_ib_ic_info);
+#endif
 
         goto out;
 
diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c
index 0d654d99fe41..bfbb31f0c7fd 100644
--- a/net/rds/ib_cm.c
+++ b/net/rds/ib_cm.c
@@ -678,6 +678,7 @@ static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event, bool isv6)
         return version;
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 /* Given an IPv6 address, find the net_device which hosts that address and
  * return its index.  This is used by the rds_ib_cm_handle_connect() code to
  * find the interface index of where an incoming request comes from when
@@ -704,6 +705,7 @@ static u32 __rds_find_ifindex(struct net *net, const struct in6_addr *addr)
 
         return idx;
 }
+#endif
 
 int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
                              struct rdma_cm_event *event, bool isv6)
@@ -732,6 +734,7 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
 
         dp = event->param.conn.private_data;
         if (isv6) {
+#if IS_ENABLED(CONFIG_IPV6)
                 dp_cmn = &dp->ricp_v6.dp_cmn;
                 saddr6 = &dp->ricp_v6.dp_saddr;
                 daddr6 = &dp->ricp_v6.dp_daddr;
@@ -756,6 +759,10 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id,
                                 goto out;
                         }
                 }
+#else
+                err = -EOPNOTSUPP;
+                goto out;
+#endif
         } else {
                 dp_cmn = &dp->ricp_v4.dp_cmn;
                 ipv6_addr_set_v4mapped(dp->ricp_v4.dp_saddr, &s_mapped_addr);
@@ -893,9 +900,11 @@ int rds_ib_conn_path_connect(struct rds_conn_path *cp)
 
         /* XXX I wonder what affect the port space has */
         /* delegate cm event handler to rdma_transport */
+#if IS_ENABLED(CONFIG_IPV6)
         if (conn->c_isv6)
                 handler = rds6_rdma_cm_event_handler;
         else
+#endif
                 handler = rds_rdma_cm_event_handler;
         ic->i_cm_id = rdma_create_id(&init_net, handler, conn,
                                      RDMA_PS_TCP, IB_QPT_RC);
diff --git a/net/rds/ib_rdma.c b/net/rds/ib_rdma.c
index e3c8bbbdb43f..99ccafb90410 100644
--- a/net/rds/ib_rdma.c
+++ b/net/rds/ib_rdma.c
@@ -180,6 +180,7 @@ void rds_ib_get_mr_info(struct rds_ib_device *rds_ibdev, struct rds_info_rdma_co
         iinfo->rdma_mr_size = pool_1m->fmr_attr.max_pages;
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 void rds6_ib_get_mr_info(struct rds_ib_device *rds_ibdev,
                          struct rds6_info_rdma_connection *iinfo6)
 {
@@ -188,6 +189,7 @@ void rds6_ib_get_mr_info(struct rds_ib_device *rds_ibdev,
         iinfo6->rdma_mr_max = pool_1m->max_items;
         iinfo6->rdma_mr_size = pool_1m->fmr_attr.max_pages;
 }
+#endif
 
 struct rds_ib_mr *rds_ib_reuse_mr(struct rds_ib_mr_pool *pool)
 {
diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c
index ad78929036ef..6b0f57c83a2a 100644
--- a/net/rds/rdma_transport.c
+++ b/net/rds/rdma_transport.c
@@ -39,7 +39,9 @@
 
 /* Global IPv4 and IPv6 RDS RDMA listener cm_id */
 static struct rdma_cm_id *rds_rdma_listen_id;
+#if IS_ENABLED(CONFIG_IPV6)
 static struct rdma_cm_id *rds6_rdma_listen_id;
+#endif
 
 static int rds_rdma_cm_event_handler_cmn(struct rdma_cm_id *cm_id,
                                          struct rdma_cm_event *event,
@@ -155,11 +157,13 @@ int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
         return rds_rdma_cm_event_handler_cmn(cm_id, event, false);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 int rds6_rdma_cm_event_handler(struct rdma_cm_id *cm_id,
                                struct rdma_cm_event *event)
 {
         return rds_rdma_cm_event_handler_cmn(cm_id, event, true);
 }
+#endif
 
 static int rds_rdma_listen_init_common(rdma_cm_event_handler handler,
                                        struct sockaddr *sa,
@@ -214,7 +218,9 @@ out:
 static int rds_rdma_listen_init(void)
 {
         int ret;
+#if IS_ENABLED(CONFIG_IPV6)
         struct sockaddr_in6 sin6;
+#endif
         struct sockaddr_in sin;
 
         sin.sin_family = PF_INET;
@@ -226,6 +232,7 @@ static int rds_rdma_listen_init(void)
         if (ret != 0)
                 return ret;
 
+#if IS_ENABLED(CONFIG_IPV6)
         sin6.sin6_family = PF_INET6;
         sin6.sin6_addr = in6addr_any;
         sin6.sin6_port = htons(RDS_CM_PORT);
@@ -237,6 +244,7 @@ static int rds_rdma_listen_init(void)
         /* Keep going even when IPv6 is not enabled in the system. */
         if (ret != 0)
                 rdsdebug("Cannot set up IPv6 RDMA listener\n");
+#endif
         return 0;
 }
 
@@ -247,11 +255,13 @@ static void rds_rdma_listen_stop(void)
                 rdma_destroy_id(rds_rdma_listen_id);
                 rds_rdma_listen_id = NULL;
         }
+#if IS_ENABLED(CONFIG_IPV6)
         if (rds6_rdma_listen_id) {
                 rdsdebug("cm %p\n", rds6_rdma_listen_id);
                 rdma_destroy_id(rds6_rdma_listen_id);
                 rds6_rdma_listen_id = NULL;
         }
+#endif
 }
 
 static int rds_rdma_init(void)
diff --git a/net/rds/recv.c b/net/rds/recv.c
index 03cd8df54c26..504cd6bcc54c 100644
--- a/net/rds/recv.c
+++ b/net/rds/recv.c
@@ -793,6 +793,7 @@ void rds_inc_info_copy(struct rds_incoming *inc,
         rds_info_copy(iter, &minfo, sizeof(minfo));
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 void rds6_inc_info_copy(struct rds_incoming *inc,
                         struct rds_info_iterator *iter,
                         struct in6_addr *saddr, struct in6_addr *daddr,
@@ -817,3 +818,4 @@ void rds6_inc_info_copy(struct rds_incoming *inc,
 
         rds_info_copy(iter, &minfo6, sizeof(minfo6));
 }
+#endif
diff --git a/net/rds/send.c b/net/rds/send.c
index 18e2b4d3931f..36a5dba56a43 100644
--- a/net/rds/send.c
+++ b/net/rds/send.c
@@ -1103,6 +1103,7 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
                         dport = usin->sin_port;
                         break;
 
+#if IS_ENABLED(CONFIG_IPV6)
                 case AF_INET6: {
                         int addr_type;
 
@@ -1142,6 +1143,7 @@ int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
                         dport = sin6->sin6_port;
                         break;
                 }
+#endif
 
                 default:
                         ret = -EINVAL;
diff --git a/net/rds/tcp.c b/net/rds/tcp.c
index f23925af0b8d..2c7b7c352d3e 100644
--- a/net/rds/tcp.c
+++ b/net/rds/tcp.c
@@ -51,7 +51,9 @@ static LIST_HEAD(rds_tcp_tc_list);
  * rds6_tcp_tc_count counts both IPv4 and IPv6 connections.
  */
 static unsigned int rds_tcp_tc_count;
+#if IS_ENABLED(CONFIG_IPV6)
 static unsigned int rds6_tcp_tc_count;
+#endif
 
 /* Track rds_tcp_connection structs so they can be cleaned up */
 static DEFINE_SPINLOCK(rds_tcp_conn_lock);
@@ -118,7 +120,9 @@ void rds_tcp_restore_callbacks(struct socket *sock,
         /* done under the callback_lock to serialize with write_space */
         spin_lock(&rds_tcp_tc_list_lock);
         list_del_init(&tc->t_list_item);
+#if IS_ENABLED(CONFIG_IPV6)
         rds6_tcp_tc_count--;
+#endif
         if (!tc->t_cpath->cp_conn->c_isv6)
                 rds_tcp_tc_count--;
         spin_unlock(&rds_tcp_tc_list_lock);
@@ -207,7 +211,9 @@ void rds_tcp_set_callbacks(struct socket *sock, struct rds_conn_path *cp)
         /* done under the callback_lock to serialize with write_space */
         spin_lock(&rds_tcp_tc_list_lock);
         list_add_tail(&tc->t_list_item, &rds_tcp_tc_list);
+#if IS_ENABLED(CONFIG_IPV6)
         rds6_tcp_tc_count++;
+#endif
         if (!tc->t_cpath->cp_conn->c_isv6)
                 rds_tcp_tc_count++;
         spin_unlock(&rds_tcp_tc_list_lock);
@@ -273,6 +279,7 @@ out:
         spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags);
 }
 
+#if IS_ENABLED(CONFIG_IPV6)
 /* Handle RDS6_INFO_TCP_SOCKETS socket option. It returns both IPv4 and
  * IPv6 connections. IPv4 connection address is returned in an IPv4 mapped
  * address.
@@ -314,12 +321,15 @@ out:
 
         spin_unlock_irqrestore(&rds_tcp_tc_list_lock, flags);
 }
+#endif
 
 static int rds_tcp_laddr_check(struct net *net, const struct in6_addr *addr,
                                __u32 scope_id)
 {
         struct net_device *dev = NULL;
+#if IS_ENABLED(CONFIG_IPV6)
         int ret;
+#endif
 
         if (ipv6_addr_v4mapped(addr)) {
                 if (inet_addr_type(net, addr->s6_addr32[3]) == RTN_LOCAL)
@@ -340,9 +350,11 @@ static int rds_tcp_laddr_check(struct net *net, const struct in6_addr *addr,
                 }
                 rcu_read_unlock();
         }
+#if IS_ENABLED(CONFIG_IPV6)
         ret = ipv6_chk_addr(net, addr, dev, 0);
         if (ret)
                 return 0;
+#endif
         return -EADDRNOTAVAIL;
 }
 
@@ -545,18 +557,27 @@ static __net_init int rds_tcp_init_net(struct net *net)
                 err = -ENOMEM;
                 goto fail;
         }
+
+#if IS_ENABLED(CONFIG_IPV6)
         rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, true);
+#else
+        rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, false);
+#endif
         if (!rtn->rds_tcp_listen_sock) {
                 pr_warn("could not set up IPv6 listen sock\n");
 
+#if IS_ENABLED(CONFIG_IPV6)
                 /* Try IPv4 as some systems disable IPv6 */
                 rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, false);
                 if (!rtn->rds_tcp_listen_sock) {
+#endif
                         unregister_net_sysctl_table(rtn->rds_tcp_sysctl);
                         rtn->rds_tcp_sysctl = NULL;
                         err = -EAFNOSUPPORT;
                         goto fail;
+#if IS_ENABLED(CONFIG_IPV6)
                 }
+#endif
         }
         INIT_WORK(&rtn->rds_tcp_accept_w, rds_tcp_accept_worker);
         return 0;
@@ -670,7 +691,9 @@ static void rds_tcp_exit(void)
         rds_tcp_set_unloading();
         synchronize_rcu();
         rds_info_deregister_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_deregister_func(RDS6_INFO_TCP_SOCKETS, rds6_tcp_tc_info);
+#endif
         unregister_pernet_device(&rds_tcp_net_ops);
         rds_tcp_destroy_conns();
         rds_trans_unregister(&rds_tcp_transport);
@@ -702,7 +725,9 @@ static int rds_tcp_init(void)
         rds_trans_register(&rds_tcp_transport);
 
         rds_info_register_func(RDS_INFO_TCP_SOCKETS, rds_tcp_tc_info);
+#if IS_ENABLED(CONFIG_IPV6)
         rds_info_register_func(RDS6_INFO_TCP_SOCKETS, rds6_tcp_tc_info);
+#endif
 
         goto out;
 out_recv:
diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 0cf0147117d8..c12203f646da 100644
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -132,7 +132,10 @@ int rds_tcp_accept_one(struct socket *sock)
         int conn_state;
         struct rds_conn_path *cp;
         struct in6_addr *my_addr, *peer_addr;
-        int dev_if;
+#if !IS_ENABLED(CONFIG_IPV6)
+        struct in6_addr saddr, daddr;
+#endif
+        int dev_if = 0;
 
         if (!sock) /* module unload or netns delete in progress */
                 return -ENETUNREACH;
@@ -165,12 +168,21 @@ int rds_tcp_accept_one(struct socket *sock)
 
         inet = inet_sk(new_sock->sk);
 
+#if IS_ENABLED(CONFIG_IPV6)
         my_addr = &new_sock->sk->sk_v6_rcv_saddr;
         peer_addr = &new_sock->sk->sk_v6_daddr;
-        rdsdebug("accepted tcp %pI6c:%u -> %pI6c:%u\n",
+#else
+        ipv6_addr_set_v4mapped(inet->inet_saddr, &saddr);
+        ipv6_addr_set_v4mapped(inet->inet_daddr, &daddr);
+        my_addr = &saddr;
+        peer_addr = &daddr;
+#endif
+        rdsdebug("accepted family %d tcp %pI6c:%u -> %pI6c:%u\n",
+                 sock->sk->sk_family,
                  my_addr, ntohs(inet->inet_sport),
                  peer_addr, ntohs(inet->inet_dport));
 
+#if IS_ENABLED(CONFIG_IPV6)
         /* sk_bound_dev_if is not set if the peer address is not link local
          * address.  In this case, it happens that mcast_oif is set.  So
          * just use it.
@@ -184,9 +196,10 @@ int rds_tcp_accept_one(struct socket *sock)
         } else {
                 dev_if = new_sock->sk->sk_bound_dev_if;
         }
+#endif
+
         conn = rds_conn_create(sock_net(sock->sk),
-                               &new_sock->sk->sk_v6_rcv_saddr,
-                               &new_sock->sk->sk_v6_daddr,
+                               my_addr, peer_addr,
                                &rds_tcp_transport, GFP_KERNEL, dev_if);
 
         if (IS_ERR(conn)) {