rds: Changed IP address internal representation to struct in6_addr

This patch changed the internal representation of an IP address to use
struct in6_addr.  IPv4 address is stored as an IPv4 mapped address.
All the functions which take an IP address as argument are also
changed to use struct in6_addr.  But RDS socket layer is not modified
such that it still does not accept IPv6 address from an application.
And RDS layer does not accept nor initiate IPv6 connections.

The RDS netfilter header is changed.  User of RDS netfilter will need
to be re-compiled.

Orabug: 25410192

Signed-off-by: Ka-Cheong Poon <[email protected]>
Reviewed-by: Håkon Bugge <[email protected]>

Author: kcp-git

include/uapi/linux/rds.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008 Oracle.  All rights reserved.
+ * Copyright (c) 2008, 2017 Oracle and/or its affiliates. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -370,11 +370,11 @@ struct rds_rdma_send_notify {
 
 /* netfilter related components */
 struct rds_nf_hdr {
-	__be32 saddr;     /* source address of request */
-	__be32 daddr;     /* destination address */
-	__be16 sport;     /* source port number */
-	__be16 dport;     /* destination port number */
-	__be16 protocol;  /* rds socket protocol family to use */
+	struct in6_addr	saddr;     /* source address of request */
+	struct in6_addr	daddr;     /* destination address */
+	__be16		sport;     /* source port number */
+	__be16		dport;     /* destination port number */
+	__be16		protocol;  /* rds socket protocol family to use */
 
 #define RDS_NF_HDR_FLAG_BOTH (0x1) /* request needs to go locally and remote */
 #define RDS_NF_HDR_FLAG_DONE (0x2) /* the request is consumed and done */

net/rds/af_rds.c

@@ -35,6 +35,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/in.h>
+#include <linux/ipv6.h>
 #include <linux/poll.h>
 #include <linux/version.h>
 #include <linux/random.h>
@@ -145,26 +146,51 @@ void rds_wake_sk_sleep(struct rds_sock *rs)
 static int rds_getname(struct socket *sock, struct sockaddr *uaddr,
 		       int *uaddr_len, int peer)
 {
-	struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
 	struct rds_sock *rs = rds_sk_to_rs(sock->sk);
-
-	memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
+	struct sockaddr_in6 *sin6;
+	struct sockaddr_in *sin;
 
 	/* racey, don't care */
 	if (peer) {
-		if (!rs->rs_conn_addr)
+		if (ipv6_addr_any(&rs->rs_conn_addr))
 			return -ENOTCONN;
 
-		sin->sin_port = rs->rs_conn_port;
-		sin->sin_addr.s_addr = rs->rs_conn_addr;
+		if (ipv6_addr_v4mapped(&rs->rs_conn_addr)) {
+			sin = (struct sockaddr_in *)uaddr;
+			memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
+			sin->sin_family = AF_INET;
+			sin->sin_port = rs->rs_conn_port;
+			sin->sin_addr.s_addr = rs->rs_conn_addr_v4;
+			*uaddr_len = sizeof(*sin);
+		} else {
+			sin6 = (struct sockaddr_in6 *)uaddr;
+			sin6->sin6_family = AF_INET6;
+			sin6->sin6_port = rs->rs_conn_port;
+			sin6->sin6_addr = rs->rs_conn_addr;
+			sin6->sin6_flowinfo = 0;
+			/* scope_id is the same as in the bound address. */
+			sin6->sin6_scope_id = rs->rs_bound_scope_id;
+			*uaddr_len = sizeof(*sin6);
+		}
 	} else {
-		sin->sin_port = rs->rs_bound_port;
-		sin->sin_addr.s_addr = rs->rs_bound_addr;
+		if (ipv6_addr_v4mapped(&rs->rs_bound_addr)) {
+			sin = (struct sockaddr_in *)uaddr;
+			memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
+			sin->sin_family = AF_INET;
+			sin->sin_port = rs->rs_bound_port;
+			sin->sin_addr.s_addr = rs->rs_bound_addr_v4;
+			*uaddr_len = sizeof(*sin);
+		} else {
+			sin6 = (struct sockaddr_in6 *)uaddr;
+			sin6->sin6_family = AF_INET6;
+			sin6->sin6_port = rs->rs_bound_port;
+			sin6->sin6_addr = rs->rs_bound_addr;
+			sin6->sin6_flowinfo = 0;
+			sin6->sin6_scope_id = rs->rs_bound_scope_id;
+			*uaddr_len = sizeof(*sin6);
+		}
 	}
 
-	sin->sin_family = AF_INET;
-
-	*uaddr_len = sizeof(*sin);
 	return 0;
 }
 
@@ -269,26 +295,36 @@ static int rds_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 static int rds_cancel_sent_to(struct rds_sock *rs, char __user *optval,
 			      int len)
 {
+	struct sockaddr_in6 sin6;
 	struct sockaddr_in sin;
 	int ret = 0;
 
 	/* racing with another thread binding seems ok here */
-	if (rs->rs_bound_addr == 0) {
+	if (ipv6_addr_any(&rs->rs_bound_addr)) {
 		ret = -ENOTCONN; /* XXX not a great errno */
 		goto out;
 	}
 
 	if (len < sizeof(struct sockaddr_in)) {
 		ret = -EINVAL;
 		goto out;
+	} else if (len < sizeof(struct sockaddr_in6)) {
+		/* Assume IPv4 */
+		if (copy_from_user(&sin, optval, sizeof(struct sockaddr_in))) {
+			ret = -EFAULT;
+			goto out;
+		}
+		ipv6_addr_set_v4mapped(sin.sin_addr.s_addr, &sin6.sin6_addr);
+		sin6.sin6_port = sin.sin_port;
+	} else {
+		if (copy_from_user(&sin6, optval,
+				   sizeof(struct sockaddr_in6))) {
+			ret = -EFAULT;
+			goto out;
+		}
 	}
 
-	if (copy_from_user(&sin, optval, sizeof(sin))) {
-		ret = -EFAULT;
-		goto out;
-	}
-
-	rds_send_drop_to(rs, &sin);
+	rds_send_drop_to(rs, &sin6);
 out:
 	return ret;
 }
@@ -346,6 +382,7 @@ static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 {
 	struct rds_reset reset;
 	struct rds_connection *conn;
+	struct in6_addr src6, dst6;
 	LIST_HEAD(s_addr_conns);
 
 	if (optlen != sizeof(struct rds_reset))
@@ -356,30 +393,32 @@ static int rds_user_reset(struct rds_sock *rs, char __user *optval, int optlen)
 		return -EFAULT;
 
 	/* Reset all conns associated with source addr */
+	ipv6_addr_set_v4mapped(reset.src.s_addr, &src6);
 	if (reset.dst.s_addr ==  0) {
 		pr_info("RDS: Reset ALL conns for Source %pI4\n",
 			 &reset.src.s_addr);
 
 		rds_conn_laddr_list(sock_net(rds_rs_to_sk(rs)),
-				    reset.src.s_addr, &s_addr_conns);
+				    &src6, &s_addr_conns);
 		if (list_empty(&s_addr_conns))
 			goto done;
 
 		list_for_each_entry(conn, &s_addr_conns, c_laddr_node)
 			if (conn)
-				rds_user_conn_paths_drop(conn, 1);
+				rds_conn_drop(conn, DR_USER_RESET);
 		goto done;
 	}
 
-	conn = rds_conn_find(sock_net(rds_rs_to_sk(rs)),
-			     reset.src.s_addr, reset.dst.s_addr,
-			rs->rs_transport, reset.tos);
+	ipv6_addr_set_v4mapped(reset.dst.s_addr, &dst6);
+	conn = rds_conn_find(sock_net(rds_rs_to_sk(rs)), &src6, &dst6,
+			     rs->rs_transport, reset.tos,
+			     rs->rs_bound_scope_id);
 
 	if (conn) {
 		bool is_tcp = conn->c_trans->t_type == RDS_TRANS_TCP;
 
 		printk(KERN_NOTICE "Resetting RDS/%s connection <%pI4,%pI4,%d>\n",
-		       is_tcp ? "tcp" : "IB",
+		       is_tcp ? "TCP" : "IB",
 		       &reset.src.s_addr,
 		       &reset.dst.s_addr, conn->c_tos);
 		rds_user_conn_paths_drop(conn, DR_USER_RESET);
@@ -571,31 +610,41 @@ static int rds_connect(struct socket *sock, struct sockaddr *uaddr,
 		       int addr_len, int flags)
 {
 	struct sock *sk = sock->sk;
-	struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
+	struct sockaddr_in *sin;
 	struct rds_sock *rs = rds_sk_to_rs(sk);
 	int ret = 0;
 
 	lock_sock(sk);
 
-	if (addr_len != sizeof(struct sockaddr_in)) {
-		ret = -EINVAL;
-		goto out;
-	}
+	switch (addr_len) {
+	case sizeof(struct sockaddr_in):
+		sin = (struct sockaddr_in *)uaddr;
+		if (sin->sin_family != AF_INET) {
+			ret = -EAFNOSUPPORT;
+			break;
+		}
+		if (sin->sin_addr.s_addr == INADDR_ANY) {
+			ret = -EDESTADDRREQ;
+			break;
+		}
+		if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) ||
+		    sin->sin_addr.s_addr == INADDR_BROADCAST) {
+			ret = -EINVAL;
+			break;
+		}
+		ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &rs->rs_conn_addr);
+		rs->rs_conn_port = sin->sin_port;
+		break;
 
-	if (sin->sin_family != AF_INET) {
-		ret = -EAFNOSUPPORT;
-		goto out;
-	}
+	case sizeof(struct sockaddr_in6):
+		ret = -EPROTONOSUPPORT;
+		break;
 
-	if (sin->sin_addr.s_addr == htonl(INADDR_ANY)) {
-		ret = -EDESTADDRREQ;
-		goto out;
+	default:
+		ret = -EINVAL;
+		break;
 	}
 
-	rs->rs_conn_addr = sin->sin_addr.s_addr;
-	rs->rs_conn_port = sin->sin_port;
-
-out:
 	release_sock(sk);
 	return ret;
 }
@@ -659,8 +708,10 @@ static int __rds_create(struct socket *sock, struct sock *sk, int protocol)
 	rs->rs_netfilter_enabled = 0;
 	rs->rs_rx_traces = 0;
 
-	if (rs->rs_bound_addr)
-		printk(KERN_CRIT "bound addr %x at create\n", rs->rs_bound_addr);
+	if (!ipv6_addr_any(&rs->rs_bound_addr)) {
+		printk(KERN_CRIT "bound addr %pI6c at create\n",
+		       &rs->rs_bound_addr);
+	}
 
 	spin_lock_bh(&rds_sock_lock);
 	list_add_tail(&rs->rs_item, &rds_sock_list);
@@ -756,8 +807,10 @@ static void rds_sock_inc_info(struct socket *sock, unsigned int len,
 		list_for_each_entry(inc, &rs->rs_recv_queue, i_item) {
 			total++;
 			if (total <= len)
-				rds_inc_info_copy(inc, iter, inc->i_saddr,
-						  rs->rs_bound_addr, 1);
+				rds_inc_info_copy(inc, iter,
+						  inc->i_saddr.s6_addr32[3],
+						  rs->rs_bound_addr_v4,
+						  1);
 		}
 
 		read_unlock(&rs->rs_recv_lock);
@@ -786,8 +839,8 @@ static void rds_sock_info(struct socket *sock, unsigned int len,
 	list_for_each_entry(rs, &rds_sock_list, rs_item) {
 		sinfo.sndbuf = rds_sk_sndbuf(rs);
 		sinfo.rcvbuf = rds_sk_rcvbuf(rs);
-		sinfo.bound_addr = rs->rs_bound_addr;
-		sinfo.connected_addr = rs->rs_conn_addr;
+		sinfo.bound_addr = rs->rs_bound_addr_v4;
+		sinfo.connected_addr = rs->rs_conn_addr_v4;
 		sinfo.bound_port = rs->rs_bound_port;
 		sinfo.connected_port = rs->rs_conn_port;
 		sinfo.inum = sock_i_ino(rds_rs_to_sk(rs));
@@ -913,8 +966,8 @@ static void __exit rds_exit(void)
 	rds_page_exit();
 	rds_info_deregister_func(RDS_INFO_SOCKETS, rds_sock_info);
 	rds_info_deregister_func(RDS_INFO_RECV_MESSAGES, rds_sock_inc_info);
-
 }
+
 module_exit(rds_exit);
 
 u32 rds_gen_num;