6956094 rds tools do not compile with sys/rds.h header file

16 files changed, 339 insertions, 292 deletions

diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/af_rds.c b/usr/src/uts/common/io/ib/clients/rdsv3/af_rds.c
index 9ed6398fc9..25ba47fd17 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/af_rds.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/af_rds.c
@@ -444,8 +444,8 @@ rdsv3_ioctl(sock_lower_handle_t proto_handle, int cmd, intptr_t arg,
 		break;
 
 	default:
-		if ((cmd >= RDSV3_INFO_FIRST) &&
-		    (cmd <= RDSV3_INFO_LAST)) {
+		if ((cmd >= RDS_INFO_FIRST) &&
+		    (cmd <= RDS_INFO_LAST)) {
 			return (rdsv3_info_ioctl((struct rsock *)proto_handle,
 			    cmd, (char *)arg, rvalp));
 		}
@@ -527,23 +527,23 @@ rdsv3_setsockopt(sock_lower_handle_t proto_handle, int level,
 	    rs, level, optname);
 
 	switch (optname) {
-	case RDSV3_CANCEL_SENT_TO:
+	case RDS_CANCEL_SENT_TO:
 		ret = rdsv3_cancel_sent_to(rs, (char *)optval, optlen);
 		break;
-	case RDSV3_GET_MR:
+	case RDS_GET_MR:
 		ret = rdsv3_get_mr(rs, optval, optlen);
 		break;
-	case RDSV3_GET_MR_FOR_DEST:
+	case RDS_GET_MR_FOR_DEST:
 		ret = rdsv3_get_mr_for_dest(rs, optval, optlen);
 		break;
-	case RDSV3_FREE_MR:
+	case RDS_FREE_MR:
 		ret = rdsv3_free_mr(rs, optval, optlen);
 		break;
-	case RDSV3_RECVERR:
+	case RDS_RECVERR:
 		ret = rdsv3_set_bool_option(&rs->rs_recverr,
 		    (char *)optval, optlen);
 		break;
-	case RDSV3_CONG_MONITOR:
+	case RDS_CONG_MONITOR:
 		ret = rdsv3_cong_monitor(rs, (char *)optval, optlen);
 		break;
 	case SO_SNDBUF:
@@ -593,7 +593,7 @@ rdsv3_getsockopt(sock_lower_handle_t proto_handle, int level,
 			*optlen = sizeof (uint_t);
 		}
 		return (ret);
-	case RDSV3_RECVERR:
+	case RDS_RECVERR:
 		RDSV3_DPRINTF4("rdsv3_getsockopt", "RDSV3_RECVERR(%d)",
 		    rs->rs_recverr);
 		if (*optlen < sizeof (int))
@@ -881,7 +881,7 @@ rdsv3_sock_inc_info(struct rsock *sock, unsigned int len,
 	RDSV3_DPRINTF4("rdsv3_sock_inc_info", "Enter(rs: %p)",
 	    rdsv3_sk_to_rs(sock));
 
-	len /= sizeof (struct rdsv3_info_message);
+	len /= sizeof (struct rds_info_message);
 
 	mutex_enter(&rdsv3_sock_lock);
 
@@ -902,7 +902,7 @@ rdsv3_sock_inc_info(struct rsock *sock, unsigned int len,
 	mutex_exit(&rdsv3_sock_lock);
 
 	lens->nr = total;
-	lens->each = sizeof (struct rdsv3_info_message);
+	lens->each = sizeof (struct rds_info_message);
 
 	RDSV3_DPRINTF4("rdsv3_sock_inc_info", "return(rs: %p)",
 	    rdsv3_sk_to_rs(sock));
@@ -912,21 +912,21 @@ static void
 rdsv3_sock_info(struct rsock *sock, unsigned int len,
     struct rdsv3_info_iterator *iter, struct rdsv3_info_lengths *lens)
 {
-	struct rdsv3_info_socket sinfo;
+	struct rds_info_socket sinfo;
 	struct rdsv3_sock *rs;
 	unsigned long bytes;
 
 	RDSV3_DPRINTF4("rdsv3_sock_info", "Enter(rs: %p)",
 	    rdsv3_sk_to_rs(sock));
 
-	len /= sizeof (struct rdsv3_info_socket);
+	len /= sizeof (struct rds_info_socket);
 
 	mutex_enter(&rdsv3_sock_lock);
 
 	if ((len < rdsv3_sock_count) || (iter->addr == NULL))
 		goto out;
 
-	bytes = sizeof (struct rdsv3_info_socket);
+	bytes = sizeof (struct rds_info_socket);
 	RDSV3_FOR_EACH_LIST_NODE(rs, &rdsv3_sock_list, rs_item) {
 		sinfo.sndbuf = rdsv3_sk_sndbuf(rs);
 		sinfo.rcvbuf = rdsv3_sk_rcvbuf(rs);
@@ -943,7 +943,7 @@ rdsv3_sock_info(struct rsock *sock, unsigned int len,
 
 out:
 	lens->nr = rdsv3_sock_count;
-	lens->each = sizeof (struct rdsv3_info_socket);
+	lens->each = sizeof (struct rds_info_socket);
 
 	mutex_exit(&rdsv3_sock_lock);
 }
@@ -976,8 +976,8 @@ rdsv3_exit(void)
 	rdsv3_sysctl_exit();
 	rdsv3_threads_exit();
 	rdsv3_stats_exit();
-	rdsv3_info_deregister_func(RDSV3_INFO_SOCKETS, rdsv3_sock_info);
-	rdsv3_info_deregister_func(RDSV3_INFO_RECV_MESSAGES,
+	rdsv3_info_deregister_func(RDS_INFO_SOCKETS, rdsv3_sock_info);
+	rdsv3_info_deregister_func(RDS_INFO_RECV_MESSAGES,
 	    rdsv3_sock_inc_info);
 
 	if (rdsv3_rdma_dwp) {
@@ -1011,8 +1011,8 @@ rdsv3_init()
 	if (ret)
 		goto out_sysctl;
 
-	rdsv3_info_register_func(RDSV3_INFO_SOCKETS, rdsv3_sock_info);
-	rdsv3_info_register_func(RDSV3_INFO_RECV_MESSAGES, rdsv3_sock_inc_info);
+	rdsv3_info_register_func(RDS_INFO_SOCKETS, rdsv3_sock_info);
+	rdsv3_info_register_func(RDS_INFO_RECV_MESSAGES, rdsv3_sock_inc_info);
 
 	/* rdsv3_rdma_init need to be called with a little delay */
 	rdsv3_rdma_dwp = kmem_zalloc(sizeof (rdsv3_delayed_work_t), KM_SLEEP);
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/cong.c b/usr/src/uts/common/io/ib/clients/rdsv3/cong.c
index 98b678eca1..aaf83910b4 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/cong.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/cong.c
@@ -400,7 +400,7 @@ rdsv3_cong_wait(struct rdsv3_cong_map *map, uint16_be_t port, int nonblock,
 			 */
 			mutex_enter(&rs->rs_lock);
 			rs->rs_cong_mask |=
-			    RDSV3_CONG_MONITOR_MASK(ntohs(port));
+			    RDS_CONG_MONITOR_MASK(ntohs(port));
 			mutex_exit(&rs->rs_lock);
 
 			/*
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/connection.c b/usr/src/uts/common/io/ib/clients/rdsv3/connection.c
index faa3e9b621..7691b07a89 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/connection.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/connection.c
@@ -57,7 +57,7 @@ static struct kmem_cache *rdsv3_conn_slab = NULL;
 
 #define	rdsv3_conn_info_set(var, test, suffix) do {               \
 	if (test)                                               \
-		var |= RDSV3_INFO_CONNECTION_FLAG_##suffix;     \
+		var |= RDS_INFO_CONNECTION_FLAG_##suffix;     \
 } while (0)
 
 
@@ -420,7 +420,7 @@ rdsv3_conn_message_info(struct rsock *sock, unsigned int len,
 
 	RDSV3_DPRINTF4("rdsv3_conn_message_info", "Enter");
 
-	len /= sizeof (struct rdsv3_info_message);
+	len /= sizeof (struct rds_info_message);
 
 	rw_enter(&rdsv3_conn_lock, RW_READER);
 
@@ -455,7 +455,7 @@ rdsv3_conn_message_info(struct rsock *sock, unsigned int len,
 	rw_exit(&rdsv3_conn_lock);
 
 	lens->nr = total;
-	lens->each = sizeof (struct rdsv3_info_message);
+	lens->each = sizeof (struct rds_info_message);
 
 	RDSV3_DPRINTF4("rdsv3_conn_message_info", "Return");
 }
@@ -531,7 +531,7 @@ rdsv3_for_each_conn_info(struct rsock *sock, unsigned int len,
 static int
 rdsv3_conn_info_visitor(struct rdsv3_connection *conn, void *buffer)
 {
-	struct rdsv3_info_connection *cinfo = buffer;
+	struct rds_info_connection *cinfo = buffer;
 
 	cinfo->next_tx_seq = conn->c_next_tx_seq;
 	cinfo->next_rx_seq = conn->c_next_rx_seq;
@@ -559,7 +559,7 @@ rdsv3_conn_info(struct rsock *sock, unsigned int len,
     struct rdsv3_info_iterator *iter, struct rdsv3_info_lengths *lens)
 {
 	rdsv3_for_each_conn_info(sock, len, iter, lens,
-	    rdsv3_conn_info_visitor, sizeof (struct rdsv3_info_connection));
+	    rdsv3_conn_info_visitor, sizeof (struct rds_info_connection));
 }
 
 int
@@ -584,10 +584,10 @@ rdsv3_conn_init()
 
 	rdsv3_loop_init();
 
-	rdsv3_info_register_func(RDSV3_INFO_CONNECTIONS, rdsv3_conn_info);
-	rdsv3_info_register_func(RDSV3_INFO_SEND_MESSAGES,
+	rdsv3_info_register_func(RDS_INFO_CONNECTIONS, rdsv3_conn_info);
+	rdsv3_info_register_func(RDS_INFO_SEND_MESSAGES,
 	    rdsv3_conn_message_info_send);
-	rdsv3_info_register_func(RDSV3_INFO_RETRANS_MESSAGES,
+	rdsv3_info_register_func(RDS_INFO_RETRANS_MESSAGES,
 	    rdsv3_conn_message_info_retrans);
 
 	RDSV3_DPRINTF4("rdsv3_conn_init", "Return");
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/ib.c b/usr/src/uts/common/io/ib/clients/rdsv3/ib.c
index 8e7f9733bc..e64e3b2617 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/ib.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/ib.c
@@ -274,7 +274,7 @@ static int
 rds_ib_conn_info_visitor(struct rdsv3_connection *conn,
     void *buffer)
 {
-	struct rdsv3_info_rdma_connection *iinfo = buffer;
+	struct rds_info_rdma_connection *iinfo = buffer;
 	struct rdsv3_ib_connection *ic;
 
 	RDSV3_DPRINTF4("rds_ib_conn_info_visitor", "conn: %p buffer: %p",
@@ -321,7 +321,7 @@ rds_ib_ic_info(struct rsock *sock, unsigned int len,
 
 	rdsv3_for_each_conn_info(sock, len, iter, lens,
 	    rds_ib_conn_info_visitor,
-	    sizeof (struct rdsv3_info_rdma_connection));
+	    sizeof (struct rds_info_rdma_connection));
 }
 
 /*
@@ -379,7 +379,7 @@ rdsv3_ib_exit(void)
 {
 	RDSV3_DPRINTF4("rds_ib_exit", "Enter");
 
-	rdsv3_info_deregister_func(RDSV3_INFO_IB_CONNECTIONS, rds_ib_ic_info);
+	rdsv3_info_deregister_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
 	rdsv3_ib_destroy_nodev_conns();
 	ib_unregister_client(&rdsv3_ib_client);
 	rdsv3_ib_sysctl_exit();
@@ -452,7 +452,7 @@ rdsv3_ib_init(void)
 	if (ret)
 		goto out_recv;
 
-	rdsv3_info_register_func(RDSV3_INFO_IB_CONNECTIONS, rds_ib_ic_info);
+	rdsv3_info_register_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
 
 	RDSV3_DPRINTF4("rds_ib_init", "Return");
 
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/ib_rdma.c b/usr/src/uts/common/io/ib/clients/rdsv3/ib_rdma.c
index 2e98721932..8192e9978c 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/ib_rdma.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/ib_rdma.c
@@ -322,14 +322,14 @@ rdsv3_ib_create_mr_pool(struct rdsv3_ib_device *rds_ibdev)
 
 void
 rdsv3_ib_get_mr_info(struct rdsv3_ib_device *rds_ibdev,
-	struct rdsv3_info_rdma_connection *iinfo)
+	struct rds_info_rdma_connection *iinfo)
 {
 	iinfo->rdma_mr_max = rds_ibdev->max_fmrs;
 	iinfo->rdma_mr_size = rds_ibdev->fmr_message_size;
 }
 
 void *
-rdsv3_ib_get_mr(struct rdsv3_iovec *args, unsigned long nents,
+rdsv3_ib_get_mr(struct rds_iovec *args, unsigned long nents,
 	struct rdsv3_sock *rs, uint32_t *key_ret)
 {
 	struct rdsv3_ib_device *rds_ibdev;
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/ib_send.c b/usr/src/uts/common/io/ib/clients/rdsv3/ib_send.c
index d25556175d..766d143058 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/ib_send.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/ib_send.c
@@ -62,15 +62,15 @@ rdsv3_ib_send_rdma_complete(struct rdsv3_message *rm,
 		return;
 
 	case IBT_WC_SUCCESS:
-		notify_status = RDSV3_RDMA_SUCCESS;
+		notify_status = RDS_RDMA_SUCCESS;
 		break;
 
 	case IBT_WC_REMOTE_ACCESS_ERR:
-		notify_status = RDSV3_RDMA_REMOTE_ERROR;
+		notify_status = RDS_RDMA_REMOTE_ERROR;
 		break;
 
 	default:
-		notify_status = RDSV3_RDMA_OTHER_ERROR;
+		notify_status = RDS_RDMA_OTHER_ERROR;
 		break;
 	}
 	rdsv3_rdma_send_complete(rm, notify_status);
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/info.c b/usr/src/uts/common/io/ib/clients/rdsv3/info.c
index bb57aa7ea2..9a14b7d2ab 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/info.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/info.c
@@ -70,14 +70,14 @@
  */
 
 static kmutex_t rdsv3_info_lock;
-static rdsv3_info_func rdsv3_info_funcs[RDSV3_INFO_LAST - RDSV3_INFO_FIRST + 1];
+static rdsv3_info_func rdsv3_info_funcs[RDS_INFO_LAST - RDS_INFO_FIRST + 1];
 
 void
 rdsv3_info_register_func(int optname, rdsv3_info_func func)
 {
-	int offset = optname - RDSV3_INFO_FIRST;
+	int offset = optname - RDS_INFO_FIRST;
 
-	ASSERT(optname >= RDSV3_INFO_FIRST && optname <= RDSV3_INFO_LAST);
+	ASSERT(optname >= RDS_INFO_FIRST && optname <= RDS_INFO_LAST);
 
 	mutex_enter(&rdsv3_info_lock);
 	ASSERT(!rdsv3_info_funcs[offset]);
@@ -89,9 +89,9 @@ rdsv3_info_register_func(int optname, rdsv3_info_func func)
 void
 rdsv3_info_deregister_func(int optname, rdsv3_info_func func)
 {
-	int offset = optname - RDSV3_INFO_FIRST;
+	int offset = optname - RDS_INFO_FIRST;
 
-	ASSERT(optname >= RDSV3_INFO_FIRST && optname <= RDSV3_INFO_LAST);
+	ASSERT(optname >= RDS_INFO_FIRST && optname <= RDS_INFO_LAST);
 
 	mutex_enter(&rdsv3_info_lock);
 	rdsv3_info_funcs[offset] = NULL;
@@ -117,7 +117,7 @@ rdsv3_info_ioctl(struct rsock *sock, int optname, char *optval,
 	struct rds_info_arg arg;
 	uint32_t ulen = 0, klen;
 
-	func = rdsv3_info_funcs[optname - RDSV3_INFO_FIRST];
+	func = rdsv3_info_funcs[optname - RDS_INFO_FIRST];
 	if (func == NULL) {
 		RDSV3_DPRINTF2("rdsv3_info_ioctl",
 		    "No Info Function, optname: %d", optname);
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/rdma.c b/usr/src/uts/common/io/ib/clients/rdsv3/rdma.c
index 8c52bdcca6..7f37d16240 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/rdma.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/rdma.c
@@ -70,7 +70,7 @@
  * from being stored in the 'length' member of 'struct rdsv3_scatterlist'.
  */
 static unsigned int
-rdsv3_pages_in_vec(struct rdsv3_iovec *vec)
+rdsv3_pages_in_vec(struct rds_iovec *vec)
 {
 	if ((vec->addr + vec->bytes <= vec->addr) ||
 	    (vec->bytes > (uint64_t)UINT_MAX)) {
@@ -164,12 +164,12 @@ rdsv3_rdma_drop_keys(struct rdsv3_sock *rs)
 }
 
 static int
-__rdsv3_rdma_map(struct rdsv3_sock *rs, struct rdsv3_get_mr_args *args,
+__rdsv3_rdma_map(struct rdsv3_sock *rs, struct rds_get_mr_args *args,
 	uint64_t *cookie_ret, struct rdsv3_mr **mr_ret)
 {
 	struct rdsv3_mr *mr = NULL, *found;
 	void *trans_private;
-	rdsv3_rdma_cookie_t cookie;
+	rds_rdma_cookie_t cookie;
 	unsigned int nents = 0;
 	int ret;
 
@@ -194,11 +194,11 @@ __rdsv3_rdma_map(struct rdsv3_sock *rs, struct rdsv3_get_mr_args *args,
 	mr->r_trans = rs->rs_transport;
 	mr->r_sock = rs;
 
-	if (args->flags & RDSV3_RDMA_USE_ONCE)
+	if (args->flags & RDS_RDMA_USE_ONCE)
 		mr->r_use_once = 1;
-	if (args->flags & RDSV3_RDMA_INVALIDATE)
+	if (args->flags & RDS_RDMA_INVALIDATE)
 		mr->r_invalidate = 1;
-	if (args->flags & RDSV3_RDMA_READWRITE)
+	if (args->flags & RDS_RDMA_READWRITE)
 		mr->r_write = 1;
 
 	/*
@@ -233,7 +233,7 @@ __rdsv3_rdma_map(struct rdsv3_sock *rs, struct rdsv3_get_mr_args *args,
 	if (args->cookie_addr) {
 		ret = ddi_copyout((void *)&cookie,
 		    (void *)((intptr_t)args->cookie_addr),
-		    sizeof (rdsv3_rdma_cookie_t), 0);
+		    sizeof (rds_rdma_cookie_t), 0);
 		if (ret != 0) {
 			ret = -EFAULT;
 			goto out;
@@ -268,14 +268,14 @@ out:
 int
 rdsv3_get_mr(struct rdsv3_sock *rs, const void *optval, int optlen)
 {
-	struct rdsv3_get_mr_args args;
+	struct rds_get_mr_args args;
 
-	if (optlen != sizeof (struct rdsv3_get_mr_args))
+	if (optlen != sizeof (struct rds_get_mr_args))
 		return (-EINVAL);
 
 #if 1
-	bcopy((struct rdsv3_get_mr_args *)optval, &args,
-	    sizeof (struct rdsv3_get_mr_args));
+	bcopy((struct rds_get_mr_args *)optval, &args,
+	    sizeof (struct rds_get_mr_args));
 #else
 	if (ddi_copyin(optval, &args, optlen, 0))
 		return (-EFAULT);
@@ -288,15 +288,15 @@ int
 rdsv3_get_mr_for_dest(struct rdsv3_sock *rs, const void *optval,
     int optlen)
 {
-	struct rdsv3_get_mr_for_dest_args args;
-	struct rdsv3_get_mr_args new_args;
+	struct rds_get_mr_for_dest_args args;
+	struct rds_get_mr_args new_args;
 
-	if (optlen != sizeof (struct rdsv3_get_mr_for_dest_args))
+	if (optlen != sizeof (struct rds_get_mr_for_dest_args))
 		return (-EINVAL);
 
 #if 1
-	bcopy((struct rdsv3_get_mr_for_dest_args *)optval, &args,
-	    sizeof (struct rdsv3_get_mr_for_dest_args));
+	bcopy((struct rds_get_mr_for_dest_args *)optval, &args,
+	    sizeof (struct rds_get_mr_for_dest_args));
 #else
 	if (ddi_copyin(optval, &args, optlen, 0))
 		return (-EFAULT);
@@ -320,18 +320,18 @@ rdsv3_get_mr_for_dest(struct rdsv3_sock *rs, const void *optval,
 int
 rdsv3_free_mr(struct rdsv3_sock *rs, const void *optval, int optlen)
 {
-	struct rdsv3_free_mr_args args;
+	struct rds_free_mr_args args;
 	struct rdsv3_mr *mr;
 
-	if (optlen != sizeof (struct rdsv3_free_mr_args))
+	if (optlen != sizeof (struct rds_free_mr_args))
 		return (-EINVAL);
 
 #if 1
-	bcopy((struct rdsv3_free_mr_args *)optval, &args,
-	    sizeof (struct rdsv3_free_mr_args));
+	bcopy((struct rds_free_mr_args *)optval, &args,
+	    sizeof (struct rds_free_mr_args));
 #else
-	if (ddi_copyin((struct rdsv3_free_mr_args *)optval, &args,
-	    sizeof (struct rdsv3_free_mr_args), 0))
+	if (ddi_copyin((struct rds_free_mr_args *)optval, &args,
+	    sizeof (struct rds_free_mr_args), 0))
 		return (-EFAULT);
 #endif
 
@@ -354,7 +354,7 @@ rdsv3_free_mr(struct rdsv3_sock *rs, const void *optval, int optlen)
 	if (mr) {
 		avl_remove(&rs->rs_rdma_keys, &mr->r_rb_node);
 		RB_CLEAR_NODE(&mr->r_rb_node);
-		if (args.flags & RDSV3_RDMA_INVALIDATE)
+		if (args.flags & RDS_RDMA_INVALIDATE)
 			mr->r_invalidate = 1;
 	}
 	mutex_exit(&rs->rs_rdma_lock);
@@ -438,12 +438,12 @@ rdsv3_rdma_free_op(struct rdsv3_rdma_op *ro)
  * args is a pointer to an in-kernel copy in the sendmsg cmsg.
  */
 static struct rdsv3_rdma_op *
-rdsv3_rdma_prepare(struct rdsv3_sock *rs, struct rdsv3_rdma_args *args)
+rdsv3_rdma_prepare(struct rdsv3_sock *rs, struct rds_rdma_args *args)
 {
-	struct rdsv3_iovec vec;
+	struct rds_iovec vec;
 	struct rdsv3_rdma_op *op = NULL;
 	unsigned int nr_bytes;
-	struct rdsv3_iovec *local_vec;
+	struct rds_iovec *local_vec;
 	unsigned int nr;
 	unsigned int i;
 	ddi_umem_cookie_t umem_cookie;
@@ -468,9 +468,9 @@ rdsv3_rdma_prepare(struct rdsv3_sock *rs, struct rdsv3_rdma_args *args)
 		goto out;
 	}
 
-	op->r_write = !!(args->flags & RDSV3_RDMA_READWRITE);
-	op->r_fence = !!(args->flags & RDSV3_RDMA_FENCE);
-	op->r_notify = !!(args->flags & RDSV3_RDMA_NOTIFY_ME);
+	op->r_write = !!(args->flags & RDS_RDMA_READWRITE);
+	op->r_fence = !!(args->flags & RDS_RDMA_FENCE);
+	op->r_notify = !!(args->flags & RDS_RDMA_NOTIFY_ME);
 	op->r_recverr = rs->rs_recverr;
 
 	if (op->r_notify || op->r_recverr) {
@@ -487,7 +487,7 @@ rdsv3_rdma_prepare(struct rdsv3_sock *rs, struct rdsv3_rdma_args *args)
 			goto out;
 		}
 		op->r_notifier->n_user_token = args->user_token;
-		op->r_notifier->n_status = RDSV3_RDMA_SUCCESS;
+		op->r_notifier->n_status = RDS_RDMA_SUCCESS;
 	}
 
 	/*
@@ -510,12 +510,12 @@ rdsv3_rdma_prepare(struct rdsv3_sock *rs, struct rdsv3_rdma_args *args)
 	    (unsigned long long)args->remote_vec.addr,
 	    op->r_key);
 
-	local_vec = (struct rdsv3_iovec *)(unsigned long) args->local_vec_addr;
+	local_vec = (struct rds_iovec *)(unsigned long) args->local_vec_addr;
 
 	/* pin the scatter list of user buffers */
 	for (i = 0; i < args->nr_local; i++) {
 		if (ddi_copyin(&local_vec[i], &vec,
-		    sizeof (struct rdsv3_iovec), 0)) {
+		    sizeof (struct rds_iovec), 0)) {
 			ret = -EFAULT;
 			goto out;
 		}
@@ -582,14 +582,14 @@ rdsv3_cmsg_rdma_args(struct rdsv3_sock *rs, struct rdsv3_message *rm,
 	struct cmsghdr *cmsg)
 {
 	struct rdsv3_rdma_op *op;
-	struct rdsv3_rdma_args *ap;
+	struct rds_rdma_args *ap;
 
-	if (cmsg->cmsg_len < CMSG_LEN(sizeof (struct rdsv3_rdma_args)) ||
+	if (cmsg->cmsg_len < CMSG_LEN(sizeof (struct rds_rdma_args)) ||
 	    rm->m_rdma_op != NULL)
 		return (-EINVAL);
 
-	/* uint64_t alignment on struct rdsv3_get_mr_args */
-	ap = (struct rdsv3_rdma_args *)kmem_alloc(cmsg->cmsg_len, KM_SLEEP);
+	/* uint64_t alignment on struct rds_get_mr_args */
+	ap = (struct rds_rdma_args *)kmem_alloc(cmsg->cmsg_len, KM_SLEEP);
 	bcopy(CMSG_DATA(cmsg), ap, cmsg->cmsg_len);
 	op = rdsv3_rdma_prepare(rs, ap);
 	kmem_free(ap, cmsg->cmsg_len);
@@ -612,7 +612,7 @@ rdsv3_cmsg_rdma_dest(struct rdsv3_sock *rs, struct rdsv3_message *rm,
 	uint32_t r_key;
 	int err = 0;
 
-	if (cmsg->cmsg_len < CMSG_LEN(sizeof (rdsv3_rdma_cookie_t)) ||
+	if (cmsg->cmsg_len < CMSG_LEN(sizeof (rds_rdma_cookie_t)) ||
 	    rm->m_rdma_cookie != 0)
 		return (-EINVAL);
 
@@ -652,15 +652,15 @@ int
 rdsv3_cmsg_rdma_map(struct rdsv3_sock *rs, struct rdsv3_message *rm,
 	struct cmsghdr *cmsg)
 {
-	struct rdsv3_get_mr_args *mrp;
+	struct rds_get_mr_args *mrp;
 	int status;
 
-	if (cmsg->cmsg_len < CMSG_LEN(sizeof (struct rdsv3_get_mr_args)) ||
+	if (cmsg->cmsg_len < CMSG_LEN(sizeof (struct rds_get_mr_args)) ||
 	    rm->m_rdma_cookie != 0)
 		return (-EINVAL);
 
-	/* uint64_t alignment on struct rdsv3_get_mr_args */
-	mrp = (struct rdsv3_get_mr_args *)kmem_alloc(cmsg->cmsg_len, KM_SLEEP);
+	/* uint64_t alignment on struct rds_get_mr_args */
+	mrp = (struct rds_get_mr_args *)kmem_alloc(cmsg->cmsg_len, KM_SLEEP);
 	bcopy(CMSG_DATA(cmsg), mrp, cmsg->cmsg_len);
 	status = __rdsv3_rdma_map(rs, mrp, &rm->m_rdma_cookie, &rm->m_rdma_mr);
 	kmem_free(mrp, cmsg->cmsg_len);
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/rds_recv.c b/usr/src/uts/common/io/ib/clients/rdsv3/rds_recv.c
index 7831a6c52c..49bd5cf879 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/rds_recv.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/rds_recv.c
@@ -344,7 +344,7 @@ int
 rdsv3_notify_queue_get(struct rdsv3_sock *rs, struct msghdr *msghdr)
 {
 	struct rdsv3_notifier *notifier;
-	struct rdsv3_rdma_notify cmsg;
+	struct rds_rdma_notify cmsg;
 	unsigned int count = 0, max_messages = ~0U;
 	list_t copy;
 	int err = 0;
@@ -392,7 +392,7 @@ rdsv3_notify_queue_get(struct rdsv3_sock *rs, struct msghdr *msghdr)
 			cmsg.status  = notifier->n_status;
 
 			err = rdsv3_put_cmsg(msghdr, SOL_RDS,
-			    RDSV3_CMSG_RDMA_STATUS, sizeof (cmsg), &cmsg);
+			    RDS_CMSG_RDMA_STATUS, sizeof (cmsg), &cmsg);
 			if (err)
 				break;
 		}
@@ -425,7 +425,7 @@ rdsv3_notify_cong(struct rdsv3_sock *rs, struct msghdr *msghdr)
 	uint64_t notify = rs->rs_cong_notify;
 	int err;
 
-	err = rdsv3_put_cmsg(msghdr, SOL_RDS, RDSV3_CMSG_CONG_UPDATE,
+	err = rdsv3_put_cmsg(msghdr, SOL_RDS, RDS_CMSG_CONG_UPDATE,
 	    sizeof (notify), &notify);
 	if (err)
 		return (err);
@@ -443,7 +443,7 @@ rdsv3_notify_cong(struct rdsv3_sock *rs, struct msghdr *msghdr)
 static int
 rdsv3_cmsg_recv(struct rdsv3_incoming *inc, struct msghdr *msg)
 {
-	return (rdsv3_put_cmsg(msg, SOL_RDS, RDSV3_CMSG_RDMA_DEST,
+	return (rdsv3_put_cmsg(msg, SOL_RDS, RDS_CMSG_RDMA_DEST,
 	    sizeof (inc->i_rdma_cookie), &inc->i_rdma_cookie));
 }
 
@@ -648,7 +648,7 @@ rdsv3_inc_info_copy(struct rdsv3_incoming *inc,
     struct rdsv3_info_iterator *iter,
     uint32_be_t saddr, uint32_be_t daddr, int flip)
 {
-	struct rdsv3_info_message minfo;
+	struct rds_info_message minfo;
 
 	minfo.seq = ntohll(inc->i_hdr.h_sequence);
 	minfo.len = ntohl(inc->i_hdr.h_len);
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/send.c b/usr/src/uts/common/io/ib/clients/rdsv3/send.c
index 10bd2c0bc2..73e5268942 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/send.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/send.c
@@ -369,7 +369,7 @@ restart:
 
 	/* Nuke any messages we decided not to retransmit. */
 	if (!list_is_empty(&to_be_dropped))
-		rdsv3_send_remove_from_sock(&to_be_dropped, RDSV3_RDMA_DROPPED);
+		rdsv3_send_remove_from_sock(&to_be_dropped, RDS_RDMA_DROPPED);
 
 	if (conn->c_trans->xmit_complete)
 		conn->c_trans->xmit_complete(conn);
@@ -711,7 +711,7 @@ XXX
 	mutex_exit(&conn->c_lock);
 
 	/* now remove the messages from the sock list as needed */
-	rdsv3_send_remove_from_sock(&list, RDSV3_RDMA_SUCCESS);
+	rdsv3_send_remove_from_sock(&list, RDS_RDMA_SUCCESS);
 
 	RDSV3_DPRINTF4("rdsv3_send_drop_acked", "Return(conn: %p)", conn);
 }
@@ -756,7 +756,7 @@ rdsv3_send_drop_to(struct rdsv3_sock *rs, struct sockaddr_in *dest)
 		 */
 		mutex_enter(&rm->m_rs_lock);
 		/* If this is a RDMA operation, notify the app. */
-		__rdsv3_rdma_send_complete(rs, rm, RDSV3_RDMA_CANCELED);
+		__rdsv3_rdma_send_complete(rs, rm, RDS_RDMA_CANCELED);
 		rm->m_rs = NULL;
 		mutex_exit(&rm->m_rs_lock);
 
@@ -901,15 +901,15 @@ rdsv3_cmsg_send(struct rdsv3_sock *rs, struct rdsv3_message *rm,
 		 * rm->m_rdma_cookie and rm->m_rdma_mr.
 		 */
 		switch (cmsg->cmsg_type) {
-		case RDSV3_CMSG_RDMA_ARGS:
+		case RDS_CMSG_RDMA_ARGS:
 			ret = rdsv3_cmsg_rdma_args(rs, rm, cmsg);
 			break;
 
-		case RDSV3_CMSG_RDMA_DEST:
+		case RDS_CMSG_RDMA_DEST:
 			ret = rdsv3_cmsg_rdma_dest(rs, rm, cmsg);
 			break;
 
-		case RDSV3_CMSG_RDMA_MAP:
+		case RDS_CMSG_RDMA_MAP:
 			ret = rdsv3_cmsg_rdma_map(rs, rm, cmsg);
 			if (ret)
 				*allocated_mr = 1;
diff --git a/usr/src/uts/common/io/ib/clients/rdsv3/stats.c b/usr/src/uts/common/io/ib/clients/rdsv3/stats.c
index fc022dbd69..47f9c2e8c9 100644
--- a/usr/src/uts/common/io/ib/clients/rdsv3/stats.c
+++ b/usr/src/uts/common/io/ib/clients/rdsv3/stats.c
@@ -87,7 +87,7 @@ void
 rdsv3_stats_info_copy(struct rdsv3_info_iterator *iter,
     uint64_t *values, char **names, size_t nr)
 {
-	struct rdsv3_info_counter ctr;
+	struct rds_info_counter ctr;
 	size_t i;
 
 	for (i = 0; i < nr; i++) {
@@ -123,7 +123,7 @@ rdsv3_stats_info(struct rsock *sock, unsigned int len,
 	int cpu;
 	unsigned int avail;
 
-	avail = len / sizeof (struct rdsv3_info_counter);
+	avail = len / sizeof (struct rds_info_counter);
 
 	if (avail < ARRAY_SIZE(rdsv3_stat_names)) {
 		avail = 0;
@@ -146,7 +146,7 @@ rdsv3_stats_info(struct rsock *sock, unsigned int len,
 	avail -= ARRAY_SIZE(rdsv3_stat_names);
 
 trans:
-	lens->each = sizeof (struct rdsv3_info_counter);
+	lens->each = sizeof (struct rds_info_counter);
 	lens->nr = rdsv3_trans_stats_info_copy(iter, avail) +
 	    ARRAY_SIZE(rdsv3_stat_names);
 }
@@ -154,12 +154,12 @@ trans:
 void
 rdsv3_stats_exit(void)
 {
-	rdsv3_info_deregister_func(RDSV3_INFO_COUNTERS, rdsv3_stats_info);
+	rdsv3_info_deregister_func(RDS_INFO_COUNTERS, rdsv3_stats_info);
 }
 
 int
 rdsv3_stats_init(void)
 {
-	rdsv3_info_register_func(RDSV3_INFO_COUNTERS, rdsv3_stats_info);
+	rdsv3_info_register_func(RDS_INFO_COUNTERS, rdsv3_stats_info);
 	return (0);
 }
diff --git a/usr/src/uts/common/sys/ib/clients/rdsv3/ib.h b/usr/src/uts/common/sys/ib/clients/rdsv3/ib.h
index df8152d740..8e1f0f74a6 100644
--- a/usr/src/uts/common/sys/ib/clients/rdsv3/ib.h
+++ b/usr/src/uts/common/sys/ib/clients/rdsv3/ib.h
@@ -303,8 +303,8 @@ static inline void rdsv3_ib_destroy_conns(struct rdsv3_ib_device *rds_ibdev)
 int rdsv3_ib_create_mr_pool(struct rdsv3_ib_device *);
 void rdsv3_ib_destroy_mr_pool(struct rdsv3_ib_device *);
 void rdsv3_ib_get_mr_info(struct rdsv3_ib_device *rds_ibdev,
-	struct rdsv3_info_rdma_connection *iinfo);
-void *rdsv3_ib_get_mr(struct rdsv3_iovec *args, unsigned long nents,
+	struct rds_info_rdma_connection *iinfo);
+void *rdsv3_ib_get_mr(struct rds_iovec *args, unsigned long nents,
 	struct rdsv3_sock *rs, uint32_t *key_ret);
 void rdsv3_ib_sync_mr(void *trans_private, int dir);
 void rdsv3_ib_free_mr(void *trans_private, int invalidate);
diff --git a/usr/src/uts/common/sys/ib/clients/rdsv3/loop.h b/usr/src/uts/common/sys/ib/clients/rdsv3/loop.h
index 2fe413eae8..6748438771 100644
--- a/usr/src/uts/common/sys/ib/clients/rdsv3/loop.h
+++ b/usr/src/uts/common/sys/ib/clients/rdsv3/loop.h
@@ -3,17 +3,52 @@
  * Oracle elects to have and use the contents of loop.h under and
  * governed by the OpenIB.org BSD license.
  */
-
 /*
- * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008 Oracle.  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
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
  */
-
 #ifndef _RDSV3_LOOP_H
 #define	_RDSV3_LOOP_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* loop.c */
 extern struct rdsv3_transport rdsv3_loop_transport;
 
 void rdsv3_loop_exit(void);
 
+#ifdef	__cplusplus
+}
+#endif
+
 #endif /* _RDSV3_LOOP_H */
diff --git a/usr/src/uts/common/sys/ib/clients/rdsv3/rdma.h b/usr/src/uts/common/sys/ib/clients/rdsv3/rdma.h
index 37779b3390..f917db6c49 100644
--- a/usr/src/uts/common/sys/ib/clients/rdsv3/rdma.h
+++ b/usr/src/uts/common/sys/ib/clients/rdsv3/rdma.h
@@ -44,7 +44,7 @@ struct rdsv3_mr {
 
 struct rdsv3_rdma_sg {
 	ddi_umem_cookie_t umem_cookie;
-	struct rdsv3_iovec iovec;
+	struct rds_iovec iovec;
 	ibt_send_wr_t	swr;
 	ibt_mi_hdl_t	mihdl;
 	ibt_hca_hdl_t	hca_hdl;
@@ -66,20 +66,20 @@ struct rdsv3_rdma_op {
 	struct rdsv3_rdma_sg	r_rdma_sg[1];
 };
 
-static inline rdsv3_rdma_cookie_t
+static inline rds_rdma_cookie_t
 rdsv3_rdma_make_cookie(uint32_t r_key, uint32_t offset)
 {
 	return (r_key | (((uint64_t)offset) << 32));
 }
 
 static inline uint32_t
-rdsv3_rdma_cookie_key(rdsv3_rdma_cookie_t cookie)
+rdsv3_rdma_cookie_key(rds_rdma_cookie_t cookie)
 {
 	return ((uint32_t)cookie);
 }
 
 static inline uint32_t
-rdsv3_rdma_cookie_offset(rdsv3_rdma_cookie_t cookie)
+rdsv3_rdma_cookie_offset(rds_rdma_cookie_t cookie)
 {
 	return (cookie >> 32);
 }
diff --git a/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3.h b/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3.h
index 6e9f5502d3..2dde86ce00 100644
--- a/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3.h
+++ b/usr/src/uts/common/sys/ib/clients/rdsv3/rdsv3.h
@@ -241,7 +241,7 @@ struct rdsv3_incoming {
 	unsigned long		i_rx_jiffies;
 	uint32_be_t		i_saddr;
 
-	rdsv3_rdma_cookie_t	i_rdma_cookie;
+	rds_rdma_cookie_t	i_rdma_cookie;
 };
 
 /*
@@ -301,7 +301,7 @@ struct rdsv3_message {
 
 	struct rdsv3_sock	*m_rs;
 	struct rdsv3_rdma_op	*m_rdma_op;
-	rdsv3_rdma_cookie_t	m_rdma_cookie;
+	rds_rdma_cookie_t	m_rdma_cookie;
 	struct rdsv3_mr		*m_rdma_mr;
 	unsigned int		m_nents;
 	unsigned int		m_count;
@@ -390,7 +390,7 @@ struct rdsv3_transport {
 	unsigned int (*stats_info_copy)(struct rdsv3_info_iterator *iter,
 	    unsigned int avail);
 	void (*exit)(void);
-	void *(*get_mr)(struct rdsv3_iovec *sg, unsigned long nr_sg,
+	void *(*get_mr)(struct rds_iovec *sg, unsigned long nr_sg,
 	    struct rdsv3_sock *rs, uint32_t *key_ret);
 	void (*sync_mr)(void *trans_private, int direction);
 	void (*free_mr)(void *trans_private, int invalidate);
diff --git a/usr/src/uts/common/sys/rds.h b/usr/src/uts/common/sys/rds.h
index bab305c6df..087c12570b 100644
--- a/usr/src/uts/common/sys/rds.h
+++ b/usr/src/uts/common/sys/rds.h
@@ -1,15 +1,10 @@
 /*
- * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
- */
-
-/*
  * This file contains definitions used in OFED defined user/kernel
  * interfaces. These are imported from the OFED header <linux/rds.h>. Oracle
  * elects to have and use the contents of <linux/rds.h> under and governed
  * by the OpenIB.org BSD license (see below for full license text). However,
  * the following notice accompanied the original version of this file:
  */
-
 /*
  * Copyright (c) 2008 Oracle.  All rights reserved.
  *
@@ -42,50 +37,63 @@
  * SOFTWARE.
  *
  */
+#ifndef _SYS_RDS_H
+#define	_SYS_RDS_H
 
-/*
- * Include this file if the application uses rdsv3 sockets.
- */
-
-/*
- * This file contains definitions from the ofed rds.h and rds_rdma.h
- * header file.
- */
-#ifndef _RDSV3_RDS_H
-#define	_RDSV3_RDS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+#if !(defined(__SVR4) && defined(__sun))
+#include <linux/types.h>
+#else
 #include <sys/types.h>
 #include <sys/socket.h>
+#endif
 
-#ifdef __cplusplus
-extern "C" {
+/*
+ * These sparse annotated types shouldn't be in any user
+ * visible header file. We should clean this up rather
+ * than kludging around them.
+ */
+#if !(defined(__SVR4) && defined(__sun))
+#ifndef __KERNEL__
+#define	__be16	u_int16_t
+#define	__be32	u_int32_t
+#define	__be64	u_int64_t
+#endif
+#else
+#define	u_int8_t	uint8_t
+#define	u_int16_t	uint16_t
+#define	u_int32_t	uint32_t
+#define	u_int64_t	uint64_t
 #endif
 
 #define	RDS_IB_ABI_VERSION		0x301
 
-#define	AF_RDS				AF_INET_OFFLOAD
-#define	PF_RDS				AF_INET_OFFLOAD
-
-#define	SOL_RDS				272
+#define	AF_RDS	AF_INET_OFFLOAD
+#define	PF_RDS	AF_INET_OFFLOAD
+#define	SOL_RDS	272
 
 /*
  * setsockopt/getsockopt for SOL_RDS
  */
-#define	RDSV3_CANCEL_SENT_TO		1
-#define	RDSV3_GET_MR			2
-#define	RDSV3_FREE_MR			3
+#define	RDS_CANCEL_SENT_TO	1
+#define	RDS_GET_MR			2
+#define	RDS_FREE_MR			3
 /* deprecated: RDS_BARRIER 4 */
-#define	RDSV3_RECVERR			5
-#define	RDSV3_CONG_MONITOR		6
-#define	RDSV3_GET_MR_FOR_DEST		7
+#define	RDS_RECVERR			5
+#define	RDS_CONG_MONITOR		6
+#define	RDS_GET_MR_FOR_DEST		7
+
 
 /*
  * Control message types for SOL_RDS.
  *
- * RDS_CMSG_RDMA_ARGS (sendmsg)
+ * CMSG_RDMA_ARGS (sendmsg)
  *	Request a RDMA transfer to/from the specified
  *	memory ranges.
- *	The cmsg_data is a struct rdsv3_rdma_args.
+ *	The cmsg_data is a struct rds_rdma_args.
  * RDS_CMSG_RDMA_DEST (recvmsg, sendmsg)
  *	Kernel informs application about intended
  *	source/destination of a RDMA transfer
@@ -93,177 +101,184 @@ extern "C" {
  *	Application asks kernel to map the given
  *	memory range into a IB MR, and send the
  *	R_Key along in an RDS extension header.
- *	The cmsg_data is a struct rdsv3_get_mr_args,
+ *	The cmsg_data is a struct rds_get_mr_args,
  *	the same as for the GET_MR setsockopt.
  * RDS_CMSG_RDMA_STATUS (recvmsg)
  *	Returns the status of a completed RDMA operation.
  */
-#define	RDSV3_CMSG_RDMA_ARGS		1
-#define	RDSV3_CMSG_RDMA_DEST		2
-#define	RDSV3_CMSG_RDMA_MAP		3
-#define	RDSV3_CMSG_RDMA_STATUS		4
-#define	RDSV3_CMSG_CONG_UPDATE		5
-
-/* rds-info related */
-
-#define	RDSV3_INFO_FIRST		10000
-#define	RDSV3_INFO_COUNTERS		10000
-#define	RDSV3_INFO_CONNECTIONS		10001
+#define	RDS_CMSG_RDMA_ARGS		1
+#define	RDS_CMSG_RDMA_DEST		2
+#define	RDS_CMSG_RDMA_MAP		3
+#define	RDS_CMSG_RDMA_STATUS		4
+#define	RDS_CMSG_CONG_UPDATE		5
+
+#define	RDS_INFO_FIRST			10000
+#define	RDS_INFO_COUNTERS		10000
+#define	RDS_INFO_CONNECTIONS		10001
 /* 10002 aka RDS_INFO_FLOWS is deprecated */
-#define	RDSV3_INFO_SEND_MESSAGES	10003
-#define	RDSV3_INFO_RETRANS_MESSAGES	10004
-#define	RDSV3_INFO_RECV_MESSAGES	10005
-#define	RDSV3_INFO_SOCKETS		10006
-#define	RDSV3_INFO_TCP_SOCKETS		10007
-#define	RDSV3_INFO_IB_CONNECTIONS	10008
-#define	RDSV3_INFO_CONNECTION_STATS	10009
-#define	RDSV3_INFO_IWARP_CONNECTIONS	10010
-#define	RDSV3_INFO_LAST			10010
-
+#define	RDS_INFO_SEND_MESSAGES		10003
+#define	RDS_INFO_RETRANS_MESSAGES	10004
+#define	RDS_INFO_RECV_MESSAGES		10005
+#define	RDS_INFO_SOCKETS		10006
+#define	RDS_INFO_TCP_SOCKETS		10007
+#define	RDS_INFO_IB_CONNECTIONS		10008
+#define	RDS_INFO_CONNECTION_STATS	10009
+#define	RDS_INFO_IWARP_CONNECTIONS	10010
+#define	RDS_INFO_LAST			10010
+
+#if defined(__SVR4) && defined(__sun)
 struct rds_info_arg {
 	uint64_t	lenp;
 	uint64_t	datap;
 };
+#endif
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_counter {
-	uint8_t	name[32];
-	uint64_t	value;
+struct rds_info_counter {
+	u_int8_t	name[32];
+	u_int64_t	value;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_counter {
-	uint8_t	name[32];
-	uint64_t	value;
+struct rds_info_counter {
+	u_int8_t	name[32];
+	u_int64_t	value;
 };
 #endif
 
-#define	RDSV3_INFO_CONNECTION_FLAG_SENDING	0x01
-#define	RDSV3_INFO_CONNECTION_FLAG_CONNECTING	0x02
-#define	RDSV3_INFO_CONNECTION_FLAG_CONNECTED	0x04
+#define	RDS_INFO_CONNECTION_FLAG_SENDING	0x01
+#define	RDS_INFO_CONNECTION_FLAG_CONNECTING	0x02
+#define	RDS_INFO_CONNECTION_FLAG_CONNECTED	0x04
 
 #define	TRANSNAMSIZ	16
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_connection {
-	uint64_t	next_tx_seq;
-	uint64_t	next_rx_seq;
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint8_t		transport[15];		/* null term ascii */
-	uint8_t		flags;
+struct rds_info_connection {
+	u_int64_t	next_tx_seq;
+	u_int64_t	next_rx_seq;
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int8_t	transport[TRANSNAMSIZ];		/* null term ascii */
+	u_int8_t	flags;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_connection {
-	uint64_t	next_tx_seq;
-	uint64_t	next_rx_seq;
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint8_t		transport[15];		/* null term ascii */
-	uint8_t		flags;
+struct rds_info_connection {
+	u_int64_t	next_tx_seq;
+	u_int64_t	next_rx_seq;
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int8_t	transport[TRANSNAMSIZ];		/* null term ascii */
+	u_int8_t	flags;
 };
 #endif
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_flow {
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint32_t	bytes;
-	uint16_t	lport;			/* network order */
-	uint16_t	fport;			/* network order */
+struct rds_info_flow {
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int32_t	bytes;
+	u_int16_t	lport;
+	u_int16_t	fport;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_flow {
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint32_t	bytes;
-	uint16_t	lport;			/* network order */
-	uint16_t	fport;			/* network order */
+struct rds_info_flow {
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int32_t	bytes;
+	u_int16_t	lport;
+	u_int16_t	fport;
 };
 #endif
 
-#define	RDSV3_INFO_MESSAGE_FLAG_ACK		0x01
-#define	RDSV3_INFO_MESSAGE_FLAG_FAST_ACK	0x02
+#define	RDS_INFO_MESSAGE_FLAG_ACK		0x01
+#define	RDS_INFO_MESSAGE_FLAG_FAST_ACK		0x02
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_message {
-	uint64_t	seq;
-	uint32_t	len;
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint16_t	lport;			/* network order */
-	uint16_t	fport;			/* network order */
-	uint8_t		flags;
+struct rds_info_message {
+	u_int64_t	seq;
+	u_int32_t	len;
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int16_t	lport;
+	u_int16_t	fport;
+	u_int8_t	flags;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_message {
-	uint64_t	seq;
-	uint32_t	len;
-	uint32_t	laddr;			/* network order */
-	uint32_t	faddr;			/* network order */
-	uint16_t	lport;			/* network order */
-	uint16_t	fport;			/* network order */
-	uint8_t		flags;
+struct rds_info_message {
+	u_int64_t	seq;
+	u_int32_t	len;
+	u_int32_t	laddr;
+	u_int32_t	faddr;
+	u_int16_t	lport;
+	u_int16_t	fport;
+	u_int8_t	flags;
 };
 #endif
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_socket {
-	uint32_t	sndbuf;
-	uint32_t	bound_addr;		/* network order */
-	uint32_t	connected_addr;		/* network order */
-	uint16_t	bound_port;		/* network order */
-	uint16_t	connected_port;		/* network order */
-	uint32_t	rcvbuf;
-	uint64_t	inum;
+struct rds_info_socket {
+	u_int32_t	sndbuf;
+	u_int32_t	bound_addr;
+	u_int32_t	connected_addr;
+	u_int16_t	bound_port;
+	u_int16_t	connected_port;
+	u_int32_t	rcvbuf;
+	u_int64_t	inum;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_socket {
-	uint32_t	sndbuf;
-	uint32_t	bound_addr;		/* network order */
-	uint32_t	connected_addr;		/* network order */
-	uint16_t	bound_port;		/* network order */
-	uint16_t	connected_port;		/* network order */
-	uint32_t	rcvbuf;
-	uint64_t	inum;
+struct rds_info_socket {
+	u_int32_t	sndbuf;
+	u_int32_t	bound_addr;
+	u_int32_t	connected_addr;
+	u_int16_t	bound_port;
+	u_int16_t	connected_port;
+	u_int32_t	rcvbuf;
+	u_int64_t	inum;
 };
 #endif
 
 #ifndef __lock_lint
 #pragma pack(1)
-struct rdsv3_info_socket_v1 {
-	uint32_t	sndbuf;
-	uint32_t	bound_addr;		/* network order */
-	uint32_t	connected_addr;		/* network order */
-	uint16_t	bound_port;		/* network order */
-	uint16_t	connected_port;		/* network order */
-	uint32_t	rcvbuf;
+struct rds_info_tcp_socket {
+	u_int32_t	local_addr;
+	u_int16_t	local_port;
+	u_int32_t	peer_addr;
+	u_int16_t	peer_port;
+	u_int64_t	hdr_rem;
+	u_int64_t	data_rem;
+	u_int32_t	last_sent_nxt;
+	u_int32_t	last_expected_una;
+	u_int32_t	last_seen_una;
 } __attribute__((packed));
 #pragma pack()
 #else
-struct rdsv3_info_socket_v1 {
-	uint32_t	sndbuf;
-	uint32_t	bound_addr;		/* network order */
-	uint32_t	connected_addr;		/* network order */
-	uint16_t	bound_port;		/* network order */
-	uint16_t	connected_port;		/* network order */
-	uint32_t	rcvbuf;
+struct rds_info_tcp_socket {
+	u_int32_t	local_addr;
+	u_int16_t	local_port;
+	u_int32_t	peer_addr;
+	u_int16_t	peer_port;
+	u_int64_t	hdr_rem;
+	u_int64_t	data_rem;
+	u_int32_t	last_sent_nxt;
+	u_int32_t	last_expected_una;
+	u_int32_t	last_seen_una;
+} __attribute__((packed));
 };
 #endif
 
 #define	RDS_IB_GID_LEN	16
-struct rdsv3_info_rdma_connection {
-	uint32_t	src_addr;		/* network order */
-	uint32_t	dst_addr;		/* network order */
+struct rds_info_rdma_connection {
+	u_int32_t	src_addr;
+	u_int32_t	dst_addr;
 	uint8_t		src_gid[RDS_IB_GID_LEN];
 	uint8_t		dst_gid[RDS_IB_GID_LEN];
 
@@ -274,10 +289,6 @@ struct rdsv3_info_rdma_connection {
 	uint32_t	rdma_mr_size;
 };
 
-#define	rdsv3_info_ib_connection rdsv3_info_rdma_connection
-#define	rdma_fmr_max rdma_mr_max
-#define	rdma_fmr_size rdma_mr_size
-
 /*
  * Congestion monitoring.
  * Congestion control in RDS happens at the host connection
@@ -301,10 +312,10 @@ struct rdsv3_info_rdma_connection {
  * The correspondence between bits and ports is
  *	1 << (portnum % 64)
  */
-#define	RDSV3_CONG_MONITOR_SIZE	64
-#define	RDSV3_CONG_MONITOR_BIT(port)	\
-	(((unsigned int) port) % RDSV3_CONG_MONITOR_SIZE)
-#define	RDSV3_CONG_MONITOR_MASK(port) (1ULL << RDSV3_CONG_MONITOR_BIT(port))
+#define	RDS_CONG_MONITOR_SIZE	64
+#define	RDS_CONG_MONITOR_BIT(port)  \
+	(((unsigned int) port) % RDS_CONG_MONITOR_SIZE)
+#define	RDS_CONG_MONITOR_MASK(port) (1ULL << RDS_CONG_MONITOR_BIT(port))
 
 /*
  * RDMA related types
@@ -317,63 +328,64 @@ struct rdsv3_info_rdma_connection {
  * (so that the application does not have to worry about
  * alignment).
  */
-typedef uint64_t	rdsv3_rdma_cookie_t;
+typedef u_int64_t	rds_rdma_cookie_t;
 
-struct rdsv3_iovec {
-	uint64_t	addr;
-	uint64_t	bytes;
+struct rds_iovec {
+	u_int64_t	addr;
+	u_int64_t	bytes;
 };
 
-struct rdsv3_get_mr_args {
-	struct rdsv3_iovec vec;
-	uint64_t	cookie_addr;
+struct rds_get_mr_args {
+	struct rds_iovec vec;
+	u_int64_t	cookie_addr;
 	uint64_t	flags;
 };
 
-struct rdsv3_get_mr_for_dest_args {
-	struct sockaddr_storage	dest_addr;
-	struct rdsv3_iovec 	vec;
-	uint64_t		cookie_addr;
+struct rds_get_mr_for_dest_args {
+	struct sockaddr_storage dest_addr;
+	struct rds_iovec	vec;
+	u_int64_t		cookie_addr;
 	uint64_t		flags;
 };
 
-struct rdsv3_free_mr_args {
-	rdsv3_rdma_cookie_t cookie;
-	uint64_t	flags;
+
+struct rds_free_mr_args {
+	rds_rdma_cookie_t cookie;
+	u_int64_t	flags;
 };
 
-struct rdsv3_rdma_args {
-	rdsv3_rdma_cookie_t cookie;
-	struct rdsv3_iovec remote_vec;
-	uint64_t	local_vec_addr;
-	uint64_t	nr_local;
-	uint64_t	flags;
-	uint64_t	user_token;
+struct rds_rdma_args {
+	rds_rdma_cookie_t cookie;
+	struct rds_iovec remote_vec;
+	u_int64_t	local_vec_addr;
+	u_int64_t	nr_local;
+	u_int64_t	flags;
+	u_int64_t	user_token;
 };
 
-struct rdsv3_rdma_notify {
-	uint64_t	user_token;
+struct rds_rdma_notify {
+	u_int64_t	user_token;
 	int32_t		status;
 };
 
-#define	RDSV3_RDMA_SUCCESS	0
-#define	RDSV3_RDMA_REMOTE_ERROR	1
-#define	RDSV3_RDMA_CANCELED	2
-#define	RDSV3_RDMA_DROPPED	3
-#define	RDSV3_RDMA_OTHER_ERROR	4
+#define	RDS_RDMA_SUCCESS	0
+#define	RDS_RDMA_REMOTE_ERROR	1
+#define	RDS_RDMA_CANCELED	2
+#define	RDS_RDMA_DROPPED	3
+#define	RDS_RDMA_OTHER_ERROR	4
 
 /*
  * Common set of flags for all RDMA related structs
  */
-#define	RDSV3_RDMA_READWRITE	0x0001
-#define	RDSV3_RDMA_FENCE	0x0002	/* use FENCE for immediate send */
-#define	RDSV3_RDMA_INVALIDATE	0x0004	/* invalidate R_Key after freeing MR */
-#define	RDSV3_RDMA_USE_ONCE	0x0008	/* free MR after use */
-#define	RDSV3_RDMA_DONTWAIT	0x0010	/* Don't wait in SET_BARRIER */
-#define	RDSV3_RDMA_NOTIFY_ME	0x0020	/* Notify when operation completes */
+#define	RDS_RDMA_READWRITE	0x0001
+#define	RDS_RDMA_FENCE		0x0002	/* use FENCE for immediate send */
+#define	RDS_RDMA_INVALIDATE	0x0004	/* invalidate R_Key after freeing MR */
+#define	RDS_RDMA_USE_ONCE	0x0008	/* free MR after use */
+#define	RDS_RDMA_DONTWAIT	0x0010	/* Don't wait in SET_BARRIER */
+#define	RDS_RDMA_NOTIFY_ME	0x0020	/* Notify when operation completes */
 
 #ifdef	__cplusplus
 }
 #endif
 
-#endif /* _RDSV3_RDS_H */
+#endif /* _SYS_RDS_H */