rds: Extend RDS API for IPv6 support

There are many data structures (RDS socket options) used by RDS apps
which use a 32 bit integer to store IP address. To support IPv6,
struct in6_addr needs to be used. To ensure backward compatibility, a
new data structure is introduced for each of those data structures
which use a 32 bit integer to represent an IP address. And new socket
options are introduced to use those new structures. This means that
existing apps should work without a problem with the new RDS module.
For apps which want to use IPv6, those new data structures and socket
options can be used. IPv4 mapped address is used to represent IPv4
address in the new data structures.

v4: Revert changes to SO_RDS_TRANSPORT

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>

1 files changed, 93 insertions, 8 deletions

diff --git a/net/rds/connection.c b/net/rds/connection.c
index 5c9ceed55dae..051e35c1e7c6 100644
--- a/net/rds/connection.c
+++ b/net/rds/connection.c
@@ -498,16 +498,19 @@ EXPORT_SYMBOL_GPL(rds_conn_destroy);
 
 static void __rds_inc_msg_cp(struct rds_incoming *inc,
                              struct rds_info_iterator *iter,
-                             void *saddr, void *daddr, int flip)
+                             void *saddr, void *daddr, int flip, bool isv6)
 {
-        rds_inc_info_copy(inc, iter, *(__be32 *)saddr,
-                          *(__be32 *)daddr, flip);
+        if (isv6)
+                rds6_inc_info_copy(inc, iter, saddr, daddr, flip);
+        else
+                rds_inc_info_copy(inc, iter, *(__be32 *)saddr,
+                                  *(__be32 *)daddr, flip);
 }
 
 static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
                                       struct rds_info_iterator *iter,
                                       struct rds_info_lengths *lens,
-                                      int want_send)
+                                      int want_send, bool isv6)
 {
         struct hlist_head *head;
         struct list_head *list;
@@ -518,7 +521,10 @@ static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
         size_t i;
         int j;
 
-        len /= sizeof(struct rds_info_message);
+        if (isv6)
+                len /= sizeof(struct rds6_info_message);
+        else
+                len /= sizeof(struct rds_info_message);
 
         rcu_read_lock();
 
@@ -528,6 +534,9 @@ static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
                         struct rds_conn_path *cp;
                         int npaths;
 
+                        if (!isv6 && conn->c_isv6)
+                                continue;
+
                         npaths = (conn->c_trans->t_mp_capable ?
                                  RDS_MPATH_WORKERS : 1);
 
@@ -548,7 +557,7 @@ static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
                                                                  iter,
                                                                  &conn->c_laddr,
                                                                  &conn->c_faddr,
-                                                                 0);
+                                                                 0, isv6);
                                 }
 
                                 spin_unlock_irqrestore(&cp->cp_lock, flags);
@@ -558,7 +567,10 @@ static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len,
         rcu_read_unlock();
 
         lens->nr = total;
-        lens->each = sizeof(struct rds_info_message);
+        if (isv6)
+                lens->each = sizeof(struct rds6_info_message);
+        else
+                lens->each = sizeof(struct rds_info_message);
 }
 
 static void rds_conn_message_info(struct socket *sock, unsigned int len,
@@ -566,7 +578,15 @@ static void rds_conn_message_info(struct socket *sock, unsigned int len,
                                   struct rds_info_lengths *lens,
                                   int want_send)
 {
-        rds_conn_message_info_cmn(sock, len, iter, lens, want_send);
+        rds_conn_message_info_cmn(sock, len, iter, lens, want_send, false);
+}
+
+static void rds6_conn_message_info(struct socket *sock, unsigned int len,
+                                   struct rds_info_iterator *iter,
+                                   struct rds_info_lengths *lens,
+                                   int want_send)
+{
+        rds_conn_message_info_cmn(sock, len, iter, lens, want_send, true);
 }
 
 static void rds_conn_message_info_send(struct socket *sock, unsigned int len,
@@ -576,6 +596,13 @@ static void rds_conn_message_info_send(struct socket *sock, unsigned int len,
         rds_conn_message_info(sock, len, iter, lens, 1);
 }
 
+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);
+}
+
 static void rds_conn_message_info_retrans(struct socket *sock,
                                           unsigned int len,
                                           struct rds_info_iterator *iter,
@@ -584,6 +611,14 @@ static void rds_conn_message_info_retrans(struct socket *sock,
         rds_conn_message_info(sock, len, iter, lens, 0);
 }
 
+static void rds6_conn_message_info_retrans(struct socket *sock,
+                                           unsigned int len,
+                                           struct rds_info_iterator *iter,
+                                           struct rds_info_lengths *lens)
+{
+        rds6_conn_message_info(sock, len, iter, lens, 0);
+}
+
 void rds_for_each_conn_info(struct socket *sock, unsigned int len,
                           struct rds_info_iterator *iter,
                           struct rds_info_lengths *lens,
@@ -699,6 +734,34 @@ static int rds_conn_info_visitor(struct rds_conn_path *cp, void *buffer)
         return 1;
 }
 
+static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer)
+{
+        struct rds6_info_connection *cinfo6 = buffer;
+        struct rds_connection *conn = cp->cp_conn;
+
+        cinfo6->next_tx_seq = cp->cp_next_tx_seq;
+        cinfo6->next_rx_seq = cp->cp_next_rx_seq;
+        cinfo6->laddr = conn->c_laddr;
+        cinfo6->faddr = conn->c_faddr;
+        strncpy(cinfo6->transport, conn->c_trans->t_name,
+                sizeof(cinfo6->transport));
+        cinfo6->flags = 0;
+
+        rds_conn_info_set(cinfo6->flags, test_bit(RDS_IN_XMIT, &cp->cp_flags),
+                          SENDING);
+        /* XXX Future: return the state rather than these funky bits */
+        rds_conn_info_set(cinfo6->flags,
+                          atomic_read(&cp->cp_state) == RDS_CONN_CONNECTING,
+                          CONNECTING);
+        rds_conn_info_set(cinfo6->flags,
+                          atomic_read(&cp->cp_state) == RDS_CONN_UP,
+                          CONNECTED);
+        /* Just return 1 as there is no error case. This is a helper function
+         * for rds_walk_conn_path_info() and it wants a return value.
+         */
+        return 1;
+}
+
 static void rds_conn_info(struct socket *sock, unsigned int len,
                           struct rds_info_iterator *iter,
                           struct rds_info_lengths *lens)
@@ -711,6 +774,18 @@ static void rds_conn_info(struct socket *sock, unsigned int len,
                                 sizeof(struct rds_info_connection));
 }
 
+static void rds6_conn_info(struct socket *sock, unsigned int len,
+                           struct rds_info_iterator *iter,
+                           struct rds_info_lengths *lens)
+{
+        u64 buffer[(sizeof(struct rds6_info_connection) + 7) / 8];
+
+        rds_walk_conn_path_info(sock, len, iter, lens,
+                                rds6_conn_info_visitor,
+                                buffer,
+                                sizeof(struct rds6_info_connection));
+}
+
 int rds_conn_init(void)
 {
         int ret;
@@ -732,6 +807,11 @@ int rds_conn_init(void)
                                rds_conn_message_info_send);
         rds_info_register_func(RDS_INFO_RETRANS_MESSAGES,
                                rds_conn_message_info_retrans);
+        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);
 
         return 0;
 }
@@ -750,6 +830,11 @@ void rds_conn_exit(void)
                                  rds_conn_message_info_send);
         rds_info_deregister_func(RDS_INFO_RETRANS_MESSAGES,
                                  rds_conn_message_info_retrans);
+        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);
 }
 
 /*