xref: /illumos-gate/usr/src/uts/common/io/ib/clients/of/sol_ofs/sol_ib_cma.c (revision 6a634c9d)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * IB specific routines for RDMA CM functionality
 */
/* Standard driver includes */
#include <sys/types.h>
#include <sys/modctl.h>
#include <sys/errno.h>
#include <sys/stat.h>

#include <sys/ib/clients/of/sol_ofs/sol_ofs_common.h>
#include <sys/ib/clients/of/ofed_kernel.h>
#include <sys/ib/clients/of/rdma/ib_addr.h>
#include <sys/ib/clients/of/rdma/rdma_cm.h>

#include <sys/ib/clients/of/sol_ofs/sol_cma.h>
#include <sys/ib/clients/of/sol_ofs/sol_ib_cma.h>

extern char 	*sol_rdmacm_dbg_str;

/* Delay of 5 secs */
#define	SOL_OFS_REQ_DELAY	5000000

/* Default Qkey used for IPoIB. */
#define	SOL_IPOIB_DEFAULT_QKEY	0xB1B

/*	Solaris CM Event Callbacks 	*/
static ibt_cm_status_t ibcma_rc_hdlr(void *, ibt_cm_event_t *,
    ibt_cm_return_args_t *, void *, ibt_priv_data_len_t);
static ibt_cm_status_t ibcma_ud_hdlr(void *, ibt_cm_ud_event_t *,
    ibt_cm_ud_return_args_t *, void *, ibt_priv_data_len_t);
static void ibcma_multicast_hdlr(void *, ibt_status_t, ibt_mcg_info_t *);

/*	Local functions 	*/
static int ibcma_tcp_connect(struct rdma_cm_id *, ibcma_chan_t *,
    struct rdma_conn_param *);
static int ibcma_udp_connect(struct rdma_cm_id *, ibcma_chan_t *,
    struct rdma_conn_param *);
static struct rdma_cm_id *ibcma_create_new_id(struct rdma_cm_id *);
static int ibcma_query_local_ip(struct rdma_cm_id *, sol_cma_chan_t *,
    ibcma_chan_t *);
static int ibcma_get_paths(struct rdma_cm_id *, sol_cma_chan_t *,
    ibcma_chan_t *);
static void ibcma_get_devlist(sol_cma_chan_t *, ib_guid_t *, int,
    genlist_t *, boolean_t);
static int ibcma_any_addr(ibt_ip_addr_t *);
static int ibcma_get_first_ib_ipaddr(struct rdma_cm_id *);

/* Utility Conversion Routines */
static void 	ipaddr2mgid(struct sockaddr *, ib_gid_t *, ib_pkey_t);
static void 	ibt_path2ah(ibt_path_info_t *, struct ib_ah_attr *);
static void	ibt_addsvect2ah(ibt_adds_vect_t *, struct ib_ah_attr *);
static void	ibt_addsvect2sa_path(ibt_adds_vect_t *,
    struct ib_sa_path_rec *, ib_lid_t);
static void	ibt_path2sa_path(ibt_path_info_t *, struct ib_sa_path_rec *,
    ib_lid_t);
static void 	mcginfo2ah(ibt_mcg_info_t *, struct ib_ah_attr *);
static void	sockaddr2ibtaddr_port(struct rdma_cm_id *, struct sockaddr *,
    ibt_ip_addr_t *, in_port_t *);
static void ipaddr2sockaddr(ibt_ip_addr_t *, struct sockaddr *,
    in_port_t *);

#ifdef	QP_DEBUG
static void 	dump_qp_info(ibt_qp_hdl_t);
#endif
static void	dump_priv_data(void *, ibt_priv_data_len_t,
    ibt_priv_data_len_t, char *);

extern cma_chan_state_t cma_get_chan_state(sol_cma_chan_t *);

/*
 * RDMA CM API - Transport specific functions
 */
void
rdma_ib_destroy_id(struct rdma_cm_id *idp)
{
	sol_cma_chan_t		*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t		*ibchanp;
	ibt_status_t		status;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_destroy_id(%p)", idp);
	ASSERT(chanp);
	ibchanp = &(chanp->chan_ib);

	if (ibchanp->chan_mcast_cnt) {
		genlist_entry_t	*entry;
		ibcma_mcast_t	*ibmcastp;
		ib_gid_t	zero_gid;

		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "rdma_ib_destroy_id: pending mcast!!");
		entry = remove_genlist_head(&ibchanp->chan_mcast_list);
		while (entry) {
			ibmcastp = (ibcma_mcast_t *)entry->data;

			bzero(&zero_gid, sizeof (ib_gid_t));
			status = ibt_leave_mcg(ibchanp->chan_devp->dev_sgid,
			    ibmcastp->mcast_gid, zero_gid, IB_MC_JSTATE_FULL);
			if (status != IBT_SUCCESS)
				SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
				    "destroy_id: ibt_leave_mcg failed %d",
				    status);
			kmem_free(ibmcastp, sizeof (ibcma_mcast_t));

			entry = remove_genlist_head(&ibchanp->chan_mcast_list);
		}
	}
	if (ibchanp->chan_devp) {
		kmem_free(ibchanp->chan_devp, sizeof (ibcma_dev_t));
		ibchanp->chan_devp = NULL;
	}
	if (ibchanp->chan_pathp) {
		kmem_free(ibchanp->chan_pathp, ibchanp->chan_path_size);
		ibchanp->chan_pathp = NULL;
	}

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_destroy_id: return");
}

int
rdma_ib_bind_addr(struct rdma_cm_id *idp, struct sockaddr *addr)
{
	sol_cma_chan_t	*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t	*ibchanp;
	int		ret;
	in_port_t	port;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_bind_addr(%p, %p)",
	    idp, addr);
	ASSERT(chanp);
	ibchanp = &(chanp->chan_ib);

	sockaddr2ibtaddr_port(idp, addr, &ibchanp->chan_local_addr, &port);
	ibchanp->chan_addr_flag = IBCMA_LOCAL_ADDR_SET_FLAG;

	/*
	 * If this is IF_ADDR_ANY, get info of IB port with IP @.
	 * Return Failure, if there are no IB ports with IP @.
	 */
	if (sol_cma_any_addr(addr)) {
		ibchanp->chan_port = port;
		ibchanp->chan_addr_flag |= IBCMA_LOCAL_ADDR_IFADDRANY;
		return (0);
	}

	ret = ibcma_query_local_ip(idp, chanp, ibchanp);
	if (ret == 0) {
		init_genlist(&ibchanp->chan_mcast_list);
		ibchanp->chan_sid = ibt_get_ip_sid(idp->ps, port);
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "chan SID %llx , ps %x, port %x",
		    ibchanp->chan_sid, idp->ps, port);
		ibchanp->chan_port = port;
		chanp->chan_xport_type = SOL_CMA_XPORT_IB;
	}
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_bind_addr: return %x",
	    ret);
	return (ret);
}

extern void cma_resolve_addr_callback(sol_cma_chan_t *, int);
int
rdma_ib_resolve_addr(struct rdma_cm_id *idp, struct sockaddr *src_addr,
    struct sockaddr *dst_addr, int timeout_ms)
{
	sol_cma_chan_t	*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t	*ibchanp;
	int		ret;
	in_port_t	port;
	in_addr_t	remote_addr;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_resolve_addr("
	    "%p, %p, %p, %x)", idp, src_addr, dst_addr, timeout_ms);
	ASSERT(chanp);
	ibchanp = &(chanp->chan_ib);

	/*
	 * Copy src_addr if the passed src @ is valid IP address and
	 * the local @ has not been set for this CMID.
	 */
	if ((ibchanp->chan_addr_flag & IBCMA_LOCAL_ADDR_SET_FLAG) == 0 &&
	    IS_VALID_SOCKADDR(src_addr)) {
		sockaddr2ibtaddr_port(idp, src_addr, &ibchanp->chan_local_addr,
		    &port);
		ibchanp->chan_addr_flag |= IBCMA_LOCAL_ADDR_SET_FLAG;
		if (port) {
			ibchanp->chan_sid = ibt_get_ip_sid(idp->ps, port);
			SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "resolve_addr, "
			    "local @ SID %llx, ps %x, port %x",
			    ibchanp->chan_sid, idp->ps, port);
			ibchanp->chan_port = port;
		}
	}

	sockaddr2ibtaddr_port(idp, dst_addr, &ibchanp->chan_remote_addr,
	    &port);
	ibchanp->chan_addr_flag |= IBCMA_REMOTE_ADDR_SET_FLAG;
	if (ibchanp->chan_sid == 0) {
		ASSERT(!sol_cma_any_addr(dst_addr));
		ibchanp->chan_sid = ibt_get_ip_sid(idp->ps, port);
		ibchanp->chan_port = port;
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "resolve_addr, remote @ "
		    "SID %llx , ps %x, port %x", ibchanp->chan_sid,
		    idp->ps, port);
		init_genlist(&ibchanp->chan_mcast_list);
	}

	/*
	 * Return SUCCESS if remote address is a MCAST address
	 * and local address is not IF_ADDR_ANY. If local_addr
	 * is IF_ADDR_ANY and remote is MCAST, return FAILURE.
	 */
	remote_addr = htonl((ibchanp->chan_remote_addr).un.ip4addr);
	if ((ibchanp->chan_remote_addr).family == AF_INET &&
	    (remote_addr >= 0xE0000000 && remote_addr <= 0xEFFFFFFF)) {
		if (ibchanp->chan_devp) {
			SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
			    "ib_resolve_addr - mcast dest @, local IP");
			(idp->route).num_paths = 0;
			ret = 0;
		} else {
			ret = ibcma_get_first_ib_ipaddr(idp);
		}

		if (ret == 0 && idp->device == NULL)
			idp->device = sol_cma_acquire_device(ntohll(
			    ibchanp->chan_devp->dev_node_guid));

		cma_resolve_addr_callback(chanp, 0);
		return (0);
	}

	if ((ret = ibcma_get_paths(idp, chanp, ibchanp)) == 0)
		chanp->chan_xport_type = SOL_CMA_XPORT_IB;

	return (ret);
}

/*
 * Linux OFED implementation is as below :
 *	1. librdmacm sends INIT_QP_ATTR command to get QP attributes
 *	   which the kernel CM expects QP attribute to be in. Kernel
 *	   CM sets the QP attribute to be set and passes it back to
 *	   user library.
 *	2. librdmacm calls ibv_modify_qp() to modify the QP attribute.
 *         The QP attribute used is the same as the that passed by
 *		   kernel sol_ucma.
 *
 * For RC connections, Solaris ibcm manages the QP state after :
 *	CM Event Handler is called	- Passive side
 *	ibv_open_rc_channel(9f)  	- Active Side
 * The client will *not* have to do an explcit modify_qp(). To fit this
 * INIT_QP_ATTR commands *marks* the QP to fake it's attributes and
 * ignore ibv_modify_qp() for this QP. Solaris ibcm manages QP state.
 *
 * Before the above calls, the client will have to maintain the QP state.
 * The sol_ucma driver will pass the appropriate QP atrributes, for the
 * clients to pass to ibv_modify_qp().
 *
 * For UD, OFED model is adhered to till the QP is transitioned to RTS.
 * Any transitions after the QP has transitioned to RTS are ignored.
 */
int
rdma_ib_init_qp_attr(struct rdma_cm_id *idp, struct ib_qp_attr *qpattr,
    int *qp_attr_mask)
{
	sol_cma_chan_t	*chanp;
	ibcma_chan_t	*ibchanp;
	ibcma_dev_t	*devp;
	uint32_t	qpstate;

	ASSERT(idp);
	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_init_qp_attr("
	    "%p, %p, %p)", idp, qpattr, qp_attr_mask);

	if (ibchanp->chan_qpmodifyflag == 1) {
		SOL_OFS_DPRINTF_L4(sol_rdmacm_dbg_str,
		    "Ignoring Init QP Attr");
		return (0);
	}

	qpstate = qpattr->qp_state;
	bzero(qpattr, sizeof (struct ib_qp_attr));
	qpattr->qp_state = qpstate;

	devp = ibchanp->chan_devp;
	if (devp == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "init_qp_attr, devp NULL");
		return (EINVAL);
	}
	qpattr->pkey_index = devp->dev_pkey_ix;
	qpattr->port_num = devp->dev_port_num;

	if (idp->ps == RDMA_PS_TCP && qpstate == IB_QPS_INIT) {
		qpattr->qp_access_flags = IB_ACCESS_REMOTE_WRITE |
		    IB_ACCESS_REMOTE_READ;
		*qp_attr_mask = IB_QP_STATE | IB_QP_PKEY_INDEX | IB_QP_PORT |
		    IB_QP_ACCESS_FLAGS;
		return (0);
	} else if (idp->ps == RDMA_PS_TCP &&
	    qpstate == IB_QPS_RTR) {
		*qp_attr_mask = IB_QP_STATE | IB_QP_AV | IB_QP_PATH_MTU  |
		    IB_QP_DEST_QPN | IB_QP_RQ_PSN |
		    IB_QP_MAX_DEST_RD_ATOMIC | IB_QP_MIN_RNR_TIMER;
		/*
		 * Fill in valid values for address vector & Remote QPN.
		 * Fill in MTU from REQ data.
		 */
		ibt_addsvect2ah(&ibchanp->chan_rcreq_addr, &qpattr->ah_attr);
		qpattr->path_mtu = (uint32_t)
		    ((ibchanp->chan_rtr_data).req_path_mtu);
		qpattr->dest_qp_num = ibchanp->chan_rcreq_qpn;
		qpattr->rq_psn = (ibchanp->chan_rtr_data).req_rq_psn;
		qpattr->max_dest_rd_atomic = ibchanp->chan_rcreq_ra_in;
		qpattr->min_rnr_timer =
		    (ibchanp->chan_rtr_data).req_rnr_nak_time;
		return (0);
	} else if (IS_UDP_CMID(idp)) {
		if (idp->ps == RDMA_PS_UDP)
			qpattr->qkey = RDMA_UDP_QKEY;
		else
			qpattr->qkey = SOL_IPOIB_DEFAULT_QKEY;
		*qp_attr_mask = IB_QP_STATE | IB_QP_PKEY_INDEX |
		    IB_QP_PORT | IB_QP_QKEY;
		return (0);
	} else
		return (EINVAL);
}

int
rdma_ib_connect(struct rdma_cm_id *idp, struct rdma_conn_param *conn_param)
{
	sol_cma_chan_t	*chanp;
	ibcma_chan_t	*ibchanp;
	int		ret;

	ASSERT(idp);
	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_connect(%p, %p)", idp,
	    conn_param);

	ASSERT(chanp->chan_xport_type == SOL_CMA_XPORT_IB);
	if (ibchanp->chan_devp == NULL || ibchanp->chan_pathp == NULL) {
		SOL_OFS_DPRINTF_L3(sol_rdmacm_dbg_str, "rdma_ib_connect : "
		    "invalid IP @");
		return (EINVAL);
	}
	ASSERT(ibchanp->chan_devp);

	ibchanp->chan_qpmodifyflag  = 1;
	if (idp->ps == RDMA_PS_TCP)
		ret = ibcma_tcp_connect(idp, ibchanp, conn_param);
	else
		ret = ibcma_udp_connect(idp, ibchanp, conn_param);

	return (ret);
}

extern void sol_cma_add_hca_list(sol_cma_chan_t *, ib_guid_t);
void
ibcma_append_listen_list(struct rdma_cm_id  *root_idp)
{
	int			num_hcas;
	ib_guid_t		*hca_guidp;
	struct rdma_cm_id	*ep_idp;
	sol_cma_chan_t		*root_chanp, *ep_chanp;
	ibcma_chan_t		*root_ibchanp, *ep_ibchanp;
	genlist_t		dev_genlist;
	genlist_entry_t		*entry;

	sol_cma_listen_info_t	*listenp;
	ibcma_dev_t		*devp;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "append_listen(%p)", root_idp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	root_ibchanp = &root_chanp->chan_ib;

	/*
	 * Address other than IF_ADDR_ANY bound to this channel. Listen on
	 * this IP address alone.
	 */
	if (root_ibchanp->chan_devp &&
	    (root_ibchanp->chan_addr_flag & IBCMA_LOCAL_ADDR_IFADDRANY) == 0) {
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "Create listen chan");
		ep_idp = ibcma_create_new_id(root_idp);
		ASSERT(ep_idp);

		ep_chanp = (sol_cma_chan_t *)ep_idp;
		listenp = kmem_zalloc(sizeof (sol_cma_listen_info_t),
		    KM_SLEEP);
		ep_chanp->chan_listenp = listenp;

		ep_ibchanp = &ep_chanp->chan_ib;
		ep_ibchanp->chan_port = root_ibchanp->chan_port;
		listenp->listen_ep_root_entry = add_genlist(
		    &(CHAN_LISTEN_LIST(root_chanp)),
		    (uintptr_t)ep_idp, root_idp);
		devp = ep_ibchanp->chan_devp;
		sol_cma_add_hca_list(ep_chanp, ntohll(devp->dev_node_guid));
		return;
	}

	/*
	 * Get the list of IB devs with valid IP addresses
	 * Append to the list of listeners for root_idp
	 */
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "Search IP @");
	num_hcas = ibt_get_hca_list(&hca_guidp);
	ibcma_get_devlist(root_chanp, hca_guidp, num_hcas,
	    &dev_genlist, B_FALSE);
	entry = remove_genlist_head(&dev_genlist);
	while (entry) {
		devp = (ibcma_dev_t *)(entry->data);
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "Create listen chan- ALL");
		ep_idp = ibcma_create_new_id(root_idp);
		ASSERT(ep_idp);

		ep_chanp = (sol_cma_chan_t *)ep_idp;
		ep_chanp->chan_xport_type = SOL_CMA_XPORT_IB;
		ipaddr2sockaddr(&devp->dev_ipaddr,
		    &(ep_idp->route.addr.src_addr), NULL);
		listenp = kmem_zalloc(sizeof (sol_cma_listen_info_t),
		    KM_SLEEP);
		ep_chanp->chan_listenp = listenp;

		ep_ibchanp = &ep_chanp->chan_ib;
		ASSERT(ep_ibchanp->chan_devp == NULL);
		ep_ibchanp->chan_devp = devp;
		ep_ibchanp->chan_port = root_ibchanp->chan_port;

		listenp->listen_ep_root_entry = add_genlist(
		    &(CHAN_LISTEN_LIST(root_chanp)),
		    (uintptr_t)ep_idp, root_idp);
		sol_cma_add_hca_list(ep_chanp, ntohll(devp->dev_node_guid));
		kmem_free(entry, sizeof (genlist_entry_t));
		entry = remove_genlist_head(&dev_genlist);
	}
	ibt_free_hca_list(hca_guidp, num_hcas);
}

int
ibcma_init_root_chan(sol_cma_chan_t *root_chanp, sol_cma_glbl_listen_t *listenp)
{
	ibcma_chan_t		*root_ibchanp;
	ibt_srv_desc_t		service;
	ibt_status_t		status;
	struct rdma_cm_id	*root_idp;

	root_idp = &(root_chanp->chan_rdma_cm);
	root_ibchanp = &root_chanp->chan_ib;

	if (root_idp->ps == RDMA_PS_TCP)
		service.sd_handler = ibcma_rc_hdlr;
	else
		service.sd_ud_handler = ibcma_ud_hdlr;
	service.sd_flags = IBT_SRV_NO_FLAGS;
	status = ibt_register_service(root_chanp->chan_ib_client_hdl,
	    &service, root_ibchanp->chan_sid,
	    root_ibchanp->chan_port ? 1 : 0xffff,
	    &((root_chanp->chan_listenp)->listen_ib_srv_hdl),
	    NULL);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "init_root_chan: ibt_register_service ret %x"
		    "SID %x, port %x", status, root_ibchanp->chan_sid,
		    root_ibchanp->chan_port);
		return (EINVAL);
	}
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "init_root_chan: "
	    "ibt_register_service: SID %x, port %x: done",
	    root_ibchanp->chan_sid, root_ibchanp->chan_port);
	listenp->cma_listen_svc_hdl =
	    (void *)(root_chanp->chan_listenp)->listen_ib_srv_hdl;
	return (0);
}

int
ibcma_fini_root_chan(sol_cma_chan_t *rchanp)
{
	ibt_status_t	status;

	status = ibt_deregister_service(rchanp->chan_ib_client_hdl,
	    (rchanp->chan_listenp)->listen_ib_srv_hdl);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "fini_root_chan: ibt_deregister_service ret %x",
		    status);
		return (EINVAL);
	}
	return (0);
}

void
ibcma_copy_srv_hdl(sol_cma_chan_t *root_chanp, sol_cma_glbl_listen_t *listenp)
{
	(root_chanp->chan_listenp)->listen_ib_srv_hdl =
	    (ibt_srv_hdl_t)listenp->cma_listen_svc_hdl;
}

int
ibcma_fini_ep_chan(sol_cma_chan_t *ep_chanp)
{
	struct rdma_cm_id	*root_idp;
	sol_cma_chan_t		*root_chanp;
	sol_cma_listen_info_t	*root_listenp, *ep_listenp;
	ibt_status_t		status;
	ibcma_chan_t		*ep_ibchanp = &ep_chanp->chan_ib;

	ASSERT(ep_chanp);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "fini_ep_chan(%p)", ep_chanp);
	root_idp  = CHAN_LISTEN_ROOT(ep_chanp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	root_listenp = root_chanp->chan_listenp;
	ep_listenp = ep_chanp->chan_listenp;

	if (ep_ibchanp->chan_devp)
		kmem_free(ep_ibchanp->chan_devp, sizeof (ibcma_dev_t));
	if (ep_ibchanp->chan_pathp)
		kmem_free(ep_ibchanp->chan_pathp,
		    ep_ibchanp->chan_path_size);

	if (!ep_listenp->listen_ib_sbind_hdl)
		return (0);
	status = ibt_unbind_service(root_listenp->listen_ib_srv_hdl,
	    ep_listenp->listen_ib_sbind_hdl);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "fini_ep_chan(%p) : ibt_unbind_service() ret %d",
		    status);
		return (-1);
	}

	return (0);
}

uint64_t
ibcma_init_root_sid(sol_cma_chan_t *root_chanp)
{
	ibcma_chan_t		*root_ibchanp;
	struct rdma_cm_id	*root_idp;

	root_ibchanp = &root_chanp->chan_ib;
	root_idp = (struct rdma_cm_id *)root_chanp;
	if (root_ibchanp->chan_sid == 0) {
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "listen No SID : ps %x",
		    root_idp->ps);
		root_ibchanp->chan_sid = ibt_get_ip_sid(root_idp->ps,
		    root_ibchanp->chan_port);
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "chan SID %llx , ps %x, "
		    "port %x", root_ibchanp->chan_sid, root_idp->ps,
		    root_ibchanp->chan_port);
	}
	return ((uint64_t)root_ibchanp->chan_sid);
}

/*ARGSUSED*/
int
rdma_ib_listen(struct rdma_cm_id *ep_idp, int bklog)
{
	struct rdma_cm_id	*root_idp;
	ibcma_chan_t		*ep_ibchanp;
	sol_cma_chan_t		*root_chanp, *ep_chanp;
	ibcma_dev_t		*ep_devp;
	ibt_status_t		status;

	ASSERT(ep_idp);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "ib_listen(%p)", ep_idp);
	ep_chanp = (sol_cma_chan_t *)ep_idp;
	root_idp  = CHAN_LISTEN_ROOT(ep_chanp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	ep_ibchanp = &ep_chanp->chan_ib;

	ep_devp = ep_ibchanp->chan_devp;
	ASSERT(ep_devp);
	status = ibt_bind_service(
	    (root_chanp->chan_listenp)->listen_ib_srv_hdl,
	    ep_devp->dev_sgid, NULL, ep_idp,
	    &((ep_chanp->chan_listenp)->listen_ib_sbind_hdl));
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "rdma_listen_ep: "
		    "ibt_bind_service failed with %x", status);
		return (EINVAL);
	}
	return (0);
}

#define	SOL_REP_PRIV_DATA_SZ 208
int
rdma_ib_accept(struct rdma_cm_id *idp, struct rdma_conn_param *conn_param)
{
	sol_cma_chan_t	*chanp;
	ibcma_chan_t	*ibchanp;
	ibt_status_t	status;
	void		*privp = NULL;
	uint8_t		priv_len;

	ASSERT(idp);
	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_accept(%p, %p)",
	    idp, conn_param);
	if (chanp->chan_session_id == NULL) {
		SOL_OFS_DPRINTF_L4(sol_rdmacm_dbg_str,
		    "Active side, cm_proceed not needed");
		return (0);
	}

	if (!conn_param) {
		SOL_OFS_DPRINTF_L4(sol_rdmacm_dbg_str, "conn_param NULL");
		return (0);
	}

	ibchanp->chan_qpmodifyflag  = 1;
	if (idp->ps == RDMA_PS_TCP)  {
		ibt_cm_proceed_reply_t	cm_reply;

		/* Fill cm_reply */
		cm_reply.rep.cm_channel =
		    (ibt_channel_hdl_t)chanp->chan_qp_hdl;
		cm_reply.rep.cm_rdma_ra_out = conn_param->initiator_depth;
		cm_reply.rep.cm_rdma_ra_in = conn_param->responder_resources;
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "accept: "
		    "init_dept %x, resp_res %x", conn_param->initiator_depth,
		    conn_param->responder_resources);
		cm_reply.rep.cm_rnr_retry_cnt = conn_param->rnr_retry_count;
		priv_len = conn_param->private_data_len;
		if (priv_len) {
			privp = (void *)kmem_zalloc(
			    SOL_REP_PRIV_DATA_SZ, KM_SLEEP);
			bcopy((void *)conn_param->private_data,
			    privp, priv_len);
#ifdef	DEBUG
			dump_priv_data(privp, SOL_REP_PRIV_DATA_SZ,
			    conn_param->private_data_len, "ib_accept");
#endif
		}

		status = ibt_ofuvcm_proceed(IBT_CM_EVENT_REQ_RCV,
		    chanp->chan_session_id, IBT_CM_ACCEPT, &cm_reply,
		    privp, priv_len);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ib_accept: "
			    "ibt_ofuvcm_proceed failed %x", status);
			if (privp)
				kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
			return (EINVAL);
		}
		if (privp)
			kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
		chanp->chan_session_id = NULL;
	} else  {
		ibt_qp_hdl_t	qphdl = chanp->chan_qp_hdl;

		priv_len = conn_param->private_data_len;
		if (priv_len) {
			privp = (void *)kmem_zalloc(
			    SOL_REP_PRIV_DATA_SZ, KM_SLEEP);
			bcopy((void *)conn_param->private_data,
			    privp, priv_len);
#ifdef DEBUG
			dump_priv_data(privp, SOL_REP_PRIV_DATA_SZ,
			    conn_param->private_data_len, "ib_accept");
#endif
		}

		status = ibt_cm_ud_proceed(chanp->chan_session_id, qphdl,
		    IBT_CM_ACCEPT, NULL, privp, priv_len);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ib_accept: "
			    "ibt_cm_ud_proceed failed %x", status);
			if (privp)
				kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
			return (EINVAL);
		}

		if (privp)
			kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
	}
	return (0);
}

int
rdma_ib_reject(struct rdma_cm_id *idp, const void *private_data,
    uint8_t private_data_len)
{
	sol_cma_chan_t	*chanp;
	ibt_status_t	status;
	void		*privp = NULL;

	ASSERT(idp);
	chanp = (sol_cma_chan_t *)idp;
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "rdma_ib_reject(%p, %p, %x)", idp,
	    private_data, private_data_len);

	if (chanp->chan_session_id == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "rdma_ib_reject :"
		    "chan_session_id NULL");
		return (EINVAL);
	}

	if (private_data_len) {
		privp = (void *)kmem_zalloc(SOL_REP_PRIV_DATA_SZ,
		    KM_SLEEP);
		bcopy((void *)private_data, privp,
		    private_data_len);
#ifdef	DEBUG
		dump_priv_data(privp, SOL_REP_PRIV_DATA_SZ,
		    private_data_len, "ib_reject");
#endif
	}

	if (idp->ps == RDMA_PS_TCP)  {
		ibt_cm_proceed_reply_t cm_reply;

		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_reject :"
		    "calling ibt_cm_proceed");
		status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV,
		    chanp->chan_session_id, IBT_CM_REJECT, &cm_reply,
		    privp, private_data_len);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ib_reject: "
			    "ibt_cm_proceed failed %x", status);
			if (privp)
				kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
			return (EINVAL);
		}
	} else  {
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "rdma_ib_reject :"
		    "calling ibt_cm_ud_proceed");
		status = ibt_cm_ud_proceed(chanp->chan_session_id, NULL,
		    IBT_CM_REJECT, NULL, privp, private_data_len);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ib_reject: "
			    "ibt_cm_ud_proceed failed %x", status);
			if (privp)
				kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
			return (EINVAL);
		}
	}

	if (privp)
		kmem_free(privp, SOL_REP_PRIV_DATA_SZ);
	return (0);
}

int
rdma_ib_disconnect(struct rdma_cm_id *idp)
{
	sol_cma_chan_t		*root_chanp, *chanp;
	ibt_status_t		status;
	struct rdma_cm_id	*root_idp;

	ASSERT(idp);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "ib_disconnect(%p)", idp);
	chanp = (sol_cma_chan_t *)idp;

	root_idp = CHAN_LISTEN_ROOT(chanp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	if (!root_chanp)
		goto handle_close_chan;

	mutex_enter(&chanp->chan_mutex);
	if (chanp->chan_req_state == REQ_CMID_NOTIFIED ||
	    chanp->chan_req_state == REQ_CMID_CREATED) {
		CHAN_LISTEN_ROOT(chanp) = NULL;
		mutex_exit(&chanp->chan_mutex);

		if (IS_UDP_CMID(idp)) {
			status = ibt_cm_ud_proceed(chanp->chan_session_id,
			    NULL, IBT_CM_NO_CHANNEL, NULL, NULL, 0);
			if (status != IBT_SUCCESS) {
				SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
				    "ib_disconnect(%p) Reject for incoming REQ "
				    "failed, status %d", status);
				return (EINVAL);
			}
		} else {
			ibt_cm_proceed_reply_t	cm_reply;

			bzero(&cm_reply, sizeof (cm_reply));
			status = ibt_cm_proceed(IBT_CM_EVENT_REQ_RCV,
			    chanp->chan_session_id, IBT_CM_REJECT, &cm_reply,
			    NULL, 0);
			if (status != IBT_SUCCESS) {
				SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
				    "ib_disconnect(%p) Reject for incoming REQ "
				    "failed, status %d", status);
				return (EINVAL);
			}
		}
		mutex_enter(&root_chanp->chan_mutex);
		mutex_enter(&chanp->chan_mutex);
		if (REQ_CMID_IN_REQ_AVL_TREE(chanp)) {
			ASSERT(cma_get_req_idp(root_idp,
			    chanp->chan_session_id));
			avl_remove(&root_chanp->chan_req_avl_tree, idp);
			chanp->chan_req_state = REQ_CMID_SERVER_NONE;
		}
		mutex_exit(&chanp->chan_mutex);
		mutex_exit(&root_chanp->chan_mutex);
	} else
		mutex_exit(&chanp->chan_mutex);

handle_close_chan :
	/*
	 * Close RC channel for RC.
	 * No explicit Disconnect required for UD
	 */
	mutex_enter(&chanp->chan_mutex);
	if (idp->ps == RDMA_PS_TCP && chanp->chan_qp_hdl &&
	    SOL_CMID_CLOSE_REQUIRED(chanp)) {
		ibt_execution_mode_t	mode;
		void			*qp_hdl = chanp->chan_qp_hdl;


		/*
		 * No callbacks for CMIDs for which destroy_id() has
		 * been called.
		 */
		mode = (chanp->chan_cmid_destroy_state &
		    SOL_CMA_CALLER_CMID_DESTROYED) ? IBT_NOCALLBACKS :
		    IBT_BLOCKING;
		mutex_exit(&chanp->chan_mutex);
		status = ibt_close_rc_channel(qp_hdl,
		    mode, NULL, 0, NULL, NULL, NULL);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "disconnect: close_rc_channel failed %x",
			    status);
			return (EINVAL);
		}
	} else
		mutex_exit(&chanp->chan_mutex);

	return (0);
}

int
rdma_ib_join_multicast(struct rdma_cm_id *idp, struct sockaddr *addr,
    void *context)
{
	sol_cma_chan_t	*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t	*ibchanp;
	ibt_mcg_attr_t	mcg_attr;
	ibt_ip_addr_t	mcast_addr;
	ibt_mcg_info_t	*mcg_infop;
	ibt_status_t	status;
	ib_gid_t	mcast_gid, mcast_gid_horder;
	ibcma_dev_t	*devp;
	ibcma_mcast_t	*ibmcastp = NULL;

	ibchanp = &chanp->chan_ib;
	devp = ibchanp->chan_devp;
	if (devp == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "join_mcast: devp NULL");
		return (EINVAL);
	}

	ibmcastp = kmem_zalloc(sizeof (ibcma_mcast_t), KM_SLEEP);
	ibmcastp->mcast_idp = idp;
	ibmcastp->mcast_ctx = context;
	bcopy(addr, &ibmcastp->mcast_addr, sizeof (struct sockaddr));
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "join_mcast: ibmcastp %p",
	    ibmcastp);

	sockaddr2ibtaddr_port(idp, addr, &mcast_addr, NULL);

	/* Check if input @ to rdma_join_mcast is multicast IP @ */
	if (!(mcast_addr.family == AF_INET &&
	    ((htonl(mcast_addr.un.ip4addr) & 0xE0000000) ==
	    0xE0000000))) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "Invalid IP addr specified");
		kmem_free(ibmcastp, sizeof (ibcma_mcast_t));
		return (EINVAL);
	}

	bzero(&mcg_attr, sizeof (mcg_attr));
	if (sol_cma_any_addr(addr)) {
		bzero(&mcast_gid, sizeof (mcast_gid));
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ANY mcast addr input");
	} else {
		ipaddr2mgid(addr, &mcast_gid_horder, devp->dev_pkey);

		mcast_gid.gid_prefix = htonll(
		    mcast_gid_horder.gid_prefix);
		mcast_gid.gid_guid = htonll(
		    mcast_gid_horder.gid_guid);
	}
	bcopy(&mcast_gid, &(mcg_attr.mc_mgid), sizeof (ib_gid_t));
	mcg_attr.mc_mtu_req.r_selector = IBT_BEST;
	mcg_attr.mc_flow = 0;
	mcg_attr.mc_hop = 0xFF;
	mcg_attr.mc_tclass = 0;
	mcg_attr.mc_sl = 0;
	mcg_attr.mc_pkt_lt_req.p_selector = IBT_BEST;
	mcg_attr.mc_pkey = devp->dev_pkey;
	mcg_attr.mc_rate_req.r_selector = IBT_BEST;
	mcg_attr.mc_join_state = IB_MC_JSTATE_FULL;
	if (idp->ps == RDMA_PS_UDP)
		mcg_attr.mc_qkey = RDMA_UDP_QKEY;
	else
		mcg_attr.mc_qkey = SOL_IPOIB_DEFAULT_QKEY;
	mcg_infop = kmem_zalloc(sizeof (ibt_mcg_info_t), KM_SLEEP);

	status = ibt_join_mcg(ibchanp->chan_devp->dev_sgid,
	    &mcg_attr, mcg_infop, ibcma_multicast_hdlr, ibmcastp);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "\t join_mcast : "
		    "ibt_join_mcg failed with status %d", status);
		kmem_free(ibmcastp, sizeof (ibcma_mcast_t));
		return (EINVAL);
	}

	(void) add_genlist(&ibchanp->chan_mcast_list, (uintptr_t)ibmcastp,
	    NULL);
	ibchanp->chan_mcast_cnt++;

	return (0);
}

void
rdma_ib_leave_multicast(struct rdma_cm_id *idp, struct sockaddr *addr)
{
	sol_cma_chan_t	*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t	*ibchanp;
	ibcma_mcast_t	*ibmcastp = NULL;
	genlist_entry_t	*entry;
	ib_gid_t	zero_gid;
	ibt_status_t	status;

	ibchanp = &chanp->chan_ib;
	genlist_for_each(entry, &ibchanp->chan_mcast_list) {
		ibmcastp = (ibcma_mcast_t *)entry->data;
		ASSERT(ibmcastp);
		if (bcmp(&ibmcastp->mcast_addr, addr,
		    sizeof (struct sockaddr)) == 0) {
			delete_genlist(&ibchanp->chan_mcast_list, entry);
			break;
		}
		ibmcastp = NULL;
	}
	if (ibmcastp == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "leave_mcast: No matching @");
		return;
	}
	ibchanp->chan_mcast_cnt--;
	bzero(&zero_gid, sizeof (ib_gid_t));
	status = ibt_leave_mcg(ibchanp->chan_devp->dev_sgid,
	    ibmcastp->mcast_gid, zero_gid, IB_MC_JSTATE_FULL);
	if (status != IBT_SUCCESS)
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "leave_mcast: "
		    "ibt_leave_mcg failed %d", status);
	kmem_free(ibmcastp, sizeof (ibcma_mcast_t));
}

/* Local Functions */
#define	SOL_REQ_PRIV_DATA_SZ	96
static int
ibcma_tcp_connect(struct rdma_cm_id *idp, ibcma_chan_t *ibchanp,
    struct rdma_conn_param *conn_paramp)
{
	sol_cma_chan_t		*chanp = (sol_cma_chan_t *)idp;
	ibt_chan_open_flags_t	flags;
	ibt_chan_open_args_t	args;
	ibt_status_t		status;
	ibt_ip_cm_info_t	ipcm_info;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "tcp_connect(%p, %p, %p)", idp,
	    ibchanp, conn_paramp);
	bzero(&args, sizeof (args));
	args.oc_path_retry_cnt = conn_paramp->retry_count;
	args.oc_path_rnr_retry_cnt = conn_paramp->rnr_retry_count;
	flags = IBT_OCHAN_OFUV;
	args.oc_path = ibchanp->chan_pathp;
	(args.oc_path)->pi_sid = ibchanp->chan_sid;
	args.oc_cm_handler =  ibcma_rc_hdlr;
	args.oc_cm_clnt_private = idp;
	args.oc_rdma_ra_out = conn_paramp->initiator_depth;
	args.oc_rdma_ra_in = conn_paramp->responder_resources;
	args.oc_priv_data_len = IBT_IP_HDR_PRIV_DATA_SZ +
	    conn_paramp->private_data_len;
	args.oc_priv_data = kmem_zalloc(SOL_REQ_PRIV_DATA_SZ, KM_SLEEP);

	bcopy(&ibchanp->chan_local_addr, &ipcm_info.src_addr,
	    sizeof (ibt_ip_addr_t));
	bcopy(&ibchanp->chan_remote_addr, &ipcm_info.dst_addr,
	    sizeof (ibt_ip_addr_t));
	ipcm_info.src_port = ibchanp->chan_port;
	status = ibt_format_ip_private_data(&ipcm_info, args.oc_priv_data_len,
	    args.oc_priv_data);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "ibt_format_ip_private_data failed!!");
		kmem_free(args.oc_priv_data, SOL_REQ_PRIV_DATA_SZ);
		return (EINVAL);
	}

	if (conn_paramp->private_data_len) {
		void	*dest;

		dest = (void *)((uint8_t *)args.oc_priv_data +
		    IBT_IP_HDR_PRIV_DATA_SZ);
		bcopy(conn_paramp->private_data, dest,
		    conn_paramp->private_data_len);
	}

	/*
	 * Set the RDMA related flags for this QP, if required.
	 */
	if (conn_paramp->initiator_depth || conn_paramp->responder_resources) {
		ibt_cep_modify_flags_t	cep_flags = IBT_CEP_SET_NOTHING;
		ibt_cep_flags_t		flags = IBT_CEP_NO_FLAGS;

		if (conn_paramp->initiator_depth) {
			cep_flags |= IBT_CEP_SET_RDMA_R;
			flags |= IBT_CEP_RDMA_RD;
		}
		if (conn_paramp->responder_resources) {
			cep_flags |= IBT_CEP_SET_RDMA_W;
			flags |= IBT_CEP_RDMA_WR;
		}

		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "tcp_connect: Calling  ibt_modify_rdma(%p, %x)",
		    chanp->chan_qp_hdl, cep_flags);
		status = ibt_modify_rdma(chanp->chan_qp_hdl,
		    cep_flags, flags);
		if (status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "tcp_connect: "
			    "ibt_open_rdma failed %x", status);
			kmem_free(args.oc_priv_data, SOL_REQ_PRIV_DATA_SZ);
			return (EINVAL);
		}
	}

	dump_priv_data(args.oc_priv_data, SOL_REQ_PRIV_DATA_SZ,
	    args.oc_priv_data_len, "tcp_connect");
	chanp->chan_connect_flag = SOL_CMA_CONNECT_INITIATED;
	status = ibt_open_rc_channel(chanp->chan_qp_hdl, flags,
	    IBT_NONBLOCKING, &args, NULL);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "tcp_connect: ibv_open_rc_channel failed %x",
		    status);
		kmem_free(args.oc_priv_data, SOL_REQ_PRIV_DATA_SZ);
		chanp->chan_connect_flag = SOL_CMA_CONNECT_CLIENT_NONE;
		return (EINVAL);
	}
	kmem_free(args.oc_priv_data, SOL_REQ_PRIV_DATA_SZ);

	return (0);
}

static int
ibcma_udp_connect(struct rdma_cm_id *idp, ibcma_chan_t *ibchanp,
    struct rdma_conn_param *conn_paramp)
{
	ibt_status_t		status;
	ibt_ud_dest_attr_t	attr;
	ibt_path_info_t		*pathp;
	ibt_adds_vect_t		*addr_vect;
	ibcma_dev_t		*devp;
	ibt_ip_cm_info_t	ipcm_info;
	sol_cma_chan_t		*chanp = (sol_cma_chan_t *)idp;

	devp = ibchanp->chan_devp;
	ASSERT(devp);

	/* We always select the first path */
	pathp = ibchanp->chan_pathp;
	addr_vect = &((pathp->pi_prim_cep_path).cep_adds_vect);

	bzero(&attr, sizeof (attr));
	attr.ud_pkey_ix = devp->dev_pkey_ix;
	attr.ud_cm_handler = ibcma_ud_hdlr;
	attr.ud_cm_private = idp;
	attr.ud_priv_data_len = IBT_IP_HDR_PRIV_DATA_SZ +
	    conn_paramp->private_data_len;
	attr.ud_priv_data = kmem_zalloc(attr.ud_priv_data_len, KM_SLEEP);
	if (conn_paramp->private_data_len) {
		bcopy(conn_paramp->private_data,
		    (void *)(((char *)attr.ud_priv_data) +
		    IBT_IP_HDR_PRIV_DATA_SZ),
		    conn_paramp->private_data_len);
	}

	bcopy((void *)&ibchanp->chan_local_addr, &ipcm_info.src_addr,
	    sizeof (ibt_ip_addr_t));
	bcopy((void *)&ibchanp->chan_remote_addr, &ipcm_info.dst_addr,
	    sizeof (ibt_ip_addr_t));
	ipcm_info.src_port = ibchanp->chan_port;
	status = ibt_format_ip_private_data(&ipcm_info, attr.ud_priv_data_len,
	    attr.ud_priv_data);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "\tibudp_connect: "
		    "ibt_format_ip_private_data() failed with status %d",
		    status);
		kmem_free(attr.ud_priv_data, attr.ud_priv_data_len);
		return (EINVAL);
	}
	attr.ud_sid = ibchanp->chan_sid;
	attr.ud_addr = addr_vect;

	chanp->chan_connect_flag = SOL_CMA_CONNECT_INITIATED;
	status = ibt_ud_get_dqpn(&attr, IBT_NONBLOCKING, NULL);

	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "\tibudp_connect: "
		    "ibt_ud_get_dqpn failed with status %x", status);
		kmem_free(attr.ud_priv_data, attr.ud_priv_data_len);
		chanp->chan_connect_flag = SOL_CMA_CONNECT_CLIENT_NONE;
		return (EINVAL);
	}

	kmem_free(attr.ud_priv_data, attr.ud_priv_data_len);

	return (0);
}

static int
ibcma_init_devinfo(struct rdma_cm_id *idp, ibcma_chan_t	*ibchanp,
    ibt_path_info_t *pathp)
{
	ibcma_dev_t		*devp;
	ibt_status_t		status;
	uint_t			nports, psize;
	ib_pkey_t		pkey;
	ibt_hca_portinfo_t	*pinfop;

	if (ibchanp->chan_devp)
		return (-1);

	/* Get the port_info and the pkey */
	status = ibt_query_hca_ports_byguid(pathp->pi_hca_guid,
	    pathp->pi_prim_cep_path.cep_hca_port_num,
	    &pinfop, &nports, &psize);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "init_devinfo - "
		    "query_hca_port failed rc %d", status);
		return (-1);
	} else {
		int	index;

		index = pathp->pi_prim_cep_path.cep_pkey_ix;
		pkey = (pinfop->p_pkey_tbl)[index];
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "init_devinfo - pkey %x",
		    pkey);
		ibt_free_portinfo(pinfop, psize);
	}
	devp = kmem_zalloc(sizeof (ibcma_dev_t), KM_SLEEP);
	ibchanp->chan_devp = devp;
	devp->dev_node_guid = pathp->pi_hca_guid;
	devp->dev_port_num = pathp->pi_prim_cep_path.cep_hca_port_num;
	devp->dev_pkey_ix = pathp->pi_prim_cep_path.cep_pkey_ix;
	devp->dev_pkey = pkey;
	devp->dev_sgid = pathp->pi_prim_cep_path.cep_adds_vect.av_sgid;

	idp->device = sol_cma_acquire_device(ntohll(devp->dev_node_guid));
	idp->port_num = devp->dev_port_num;
	return (0);
}

static int
ibcma_query_local_ip(struct rdma_cm_id *idp, sol_cma_chan_t *chanp,
    ibcma_chan_t *ibchanp)
{
	ibt_status_t		status;
	ibt_ip_addr_t		*local_addrp;
	ibt_ip_path_attr_t	path_attr;
	ibt_path_info_t		local_path;

	if (ibchanp->chan_pathp != NULL) {
		return (0);
	}
	local_addrp = &ibchanp->chan_local_addr;
	bzero(&path_attr, sizeof (path_attr));
	path_attr.ipa_dst_ip = local_addrp;
	bcopy(local_addrp, &path_attr.ipa_src_ip, sizeof (ibt_ip_addr_t));
	path_attr.ipa_ndst = 1;
	path_attr.ipa_max_paths = 1;
	path_attr.ipa_zoneid = 0;

	if ((status = ibt_get_ip_paths(chanp->chan_ib_client_hdl,
	    IBT_PATH_NO_FLAGS, &path_attr, &local_path, NULL, NULL)) !=
	    IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "ib_cma_get_devinfo:status %d,  %p not IB IP @",
		    status, local_addrp);
		return (EINVAL);
	}
	if (ibcma_init_devinfo(idp, ibchanp, &local_path)) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "ib_cma_get_devinfo:init_devinfo failed");
		return (EINVAL);
	}

	return (0);
}

#define	IBCMA_FREE_IN_IPPATH_HDLR()				\
	if (pathp)						\
		kmem_free(pathp, sizeof (ibt_path_info_t) * 	\
		    num_paths);					\
	if (src_ip_p)						\
		kmem_free(src_ip_p, sizeof (ibt_path_ip_src_t) 	\
		    * num_paths);

static void
ibcma_path_hdlr(void *arg, ibt_status_t retval, ibt_path_info_t *pathp,
    uint8_t num_paths, ibt_path_ip_src_t *src_ip_p)
{
	struct rdma_cm_id	*idp = (struct rdma_cm_id *)arg;
	sol_cma_chan_t		*chanp = (sol_cma_chan_t *)arg;
	ibcma_chan_t		*ibchanp = &(chanp->chan_ib);
	int			i;
	ibcma_dev_t		*devp;
	ib_lid_t		base_lid;

	if (retval != IBT_SUCCESS && retval != IBT_INSUFF_DATA) {
		cma_resolve_addr_callback(chanp, 1);
		IBCMA_FREE_IN_IPPATH_HDLR();
		return;
	}

	ibchanp->chan_path_size = 2 * sizeof (ibt_path_info_t);
	ibchanp->chan_pathp = kmem_zalloc(ibchanp->chan_path_size, KM_SLEEP);
	bcopy(pathp, ibchanp->chan_pathp, num_paths *
	    sizeof (ibt_path_info_t));
	ibchanp->chan_numpaths = num_paths;

	if (ibchanp->chan_devp == NULL && src_ip_p) {
		ipaddr2sockaddr(&(src_ip_p[0].ip_primary),
		    &(idp->route.addr.src_addr), NULL);
		bcopy(&(src_ip_p[0].ip_primary), &ibchanp->chan_local_addr,
		    sizeof (ibt_ip_addr_t));
		if (ibcma_init_devinfo((struct rdma_cm_id *)chanp,
		    ibchanp, pathp)) {
			kmem_free(ibchanp->chan_pathp,
			    ibchanp->chan_path_size);
			cma_resolve_addr_callback(chanp, 1);
			IBCMA_FREE_IN_IPPATH_HDLR();
			return;
		}
	}

	if (ibchanp->chan_devp == NULL) {
		cma_resolve_addr_callback(chanp, 1);
		IBCMA_FREE_IN_IPPATH_HDLR();
		return;
	}

	devp = ibchanp->chan_devp;
	(idp->route).num_paths = ibchanp->chan_numpaths;
	idp->route.path_rec = kmem_zalloc(sizeof (struct ib_sa_path_rec) *
	    ibchanp->chan_numpaths, KM_SLEEP);
	base_lid = ibt_get_port_state_byguid(devp->dev_node_guid,
	    devp->dev_port_num, NULL, &base_lid);
	for (i = 0; i < ibchanp->chan_numpaths; i++)
		ibt_path2sa_path(&((ibchanp->chan_pathp)[i]),
		    &((idp->route.path_rec)[i]), base_lid);

	cma_resolve_addr_callback(chanp, 0);
	IBCMA_FREE_IN_IPPATH_HDLR();
}

static int
ibcma_get_paths(struct rdma_cm_id *idp, sol_cma_chan_t *chanp,
    ibcma_chan_t *ibchanp)
{
	ibt_ip_path_attr_t	path_attr;
	ibt_status_t		status;
	ibt_ip_addr_t		*dst_addrp;

	ASSERT(ibchanp);

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "ibcma_get_paths(%p, %p)", idp,
	    ibchanp);
	bzero(&path_attr, sizeof (ibt_ip_path_attr_t));
	dst_addrp = kmem_zalloc(sizeof (ibt_ip_addr_t), KM_SLEEP);
	bcopy(&ibchanp->chan_remote_addr, dst_addrp, sizeof (ibt_ip_addr_t));
	path_attr.ipa_dst_ip = dst_addrp;
	bcopy(&ibchanp->chan_local_addr, &path_attr.ipa_src_ip,
	    sizeof (ibt_ip_addr_t));
	path_attr.ipa_ndst = 1;
	path_attr.ipa_max_paths = 2;
	path_attr.ipa_zoneid = 0;
	if (ibcma_any_addr(&path_attr.ipa_src_ip))
		path_attr.ipa_src_ip.family = AF_UNSPEC;

	status = ibt_aget_ip_paths(chanp->chan_ib_client_hdl, IBT_PATH_NO_FLAGS,
	    &path_attr, ibcma_path_hdlr, idp);
	if (status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "cma_get_paths : ibt_aget_paths() failed %d", status);
		kmem_free(dst_addrp, sizeof (ibt_ip_addr_t));
		return (EINVAL);
	}

	kmem_free(dst_addrp, sizeof (ibt_ip_addr_t));
	return (0);
}

/*
 * Solaris Event Handlers
 */

/* UD Event Handler */
/*ARGSUSED*/
static ibt_cm_status_t
ibcma_ud_hdlr(void *inp, ibt_cm_ud_event_t *eventp,
    ibt_cm_ud_return_args_t *ret_args, void *priv_data,
    ibt_priv_data_len_t priv_datalen)
{
	struct rdma_cm_id	*root_idp, *event_idp, *idp;
	sol_cma_chan_t		*root_chanp, *chanp, *event_chanp;
	ibcma_chan_t		*ibchanp, *event_ibchanp;
	struct rdma_ud_param	ud_param, *ud_paramp = &ud_param;
	enum rdma_cm_event_type event;
	int			evt_status = -1;
	ibt_priv_data_len_t	cm_privlen;
	void			*cm_priv;
	ibt_status_t		ibt_status;
	ibt_ip_cm_info_t	info;
	cma_chan_state_t	chan_state;

	event_idp = idp = (struct rdma_cm_id *)inp;
	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;
	root_idp = CHAN_LISTEN_ROOT(chanp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	SOL_OFS_DPRINTF_L3(sol_rdmacm_dbg_str, "cma_ud_hdlr(%p, %p)",
	    inp, eventp);

	bzero(&ud_param, sizeof (struct rdma_ud_param));
	cm_privlen = eventp->cm_priv_data_len;
	cm_priv = eventp->cm_priv_data;
	if (eventp->cm_type == IBT_CM_UD_EVENT_SIDR_REQ) {
		ibt_cm_sidr_req_t	*sidr_req;
		void			*find_ret;
		avl_index_t		where;

		ASSERT(root_chanp);

		/*
		 * Reject further REQs if destroy of listen CMID
		 * has been called.
		 */
		mutex_enter(&root_chanp->chan_mutex);
		chan_state = cma_get_chan_state(root_chanp);
		mutex_exit(&root_chanp->chan_mutex);
		if (chan_state == SOL_CMA_CHAN_DESTROY_PENDING ||
		    chan_state == SOL_CMA_CHAN_DESTROY_WAIT) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "UD Req Hdlr, "
			    "listen CMID destroy called");
			return (IBT_CM_REJECT);
		}

		sidr_req = &((eventp->cm_event).sidr_req);
		SOL_OFS_DPRINTF_L4(sol_rdmacm_dbg_str, "SIDR REQ");

		if (cm_privlen < IBT_IP_HDR_PRIV_DATA_SZ) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "UD Req Hdlr, "
			    "Priv data len %x < %x", cm_privlen,
			    IBT_IP_HDR_PRIV_DATA_SZ);
			return (IBT_CM_REJECT);
		}
		ibt_status = ibt_get_ip_data(cm_privlen, cm_priv, &info);
		if (ibt_status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "UD Req Hdlr, "
			    "ibt_get_ip_data failed, %x", ibt_status);
			return (IBT_CM_REJECT);
		}
		cm_privlen -= IBT_IP_HDR_PRIV_DATA_SZ;
		cm_priv = (void *)(((uchar_t *)cm_priv) +
		    IBT_IP_HDR_PRIV_DATA_SZ);

		event_idp = ibcma_create_new_id(idp);
		if (event_idp == NULL) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "create_new_id failed!!");
			return (IBT_CM_REJECT);
		}
		event_idp->device = sol_cma_acquire_device(ntohll(
		    sidr_req->sreq_hca_guid));
		event_idp->port_num = sidr_req->sreq_hca_port;
		(event_idp->route).num_paths = 0;

		event_chanp = (sol_cma_chan_t *)event_idp;
		event_chanp->chan_req_state = REQ_CMID_NOTIFIED;
		event_ibchanp = &event_chanp->chan_ib;
		event_chanp->chan_session_id = eventp->cm_session_id;
		bcopy(&info.src_addr, &event_ibchanp->chan_remote_addr,
		    sizeof (ibt_ip_addr_t));
		ipaddr2sockaddr(&info.src_addr,
		    &(event_idp->route.addr.dst_addr), &info.src_port);
		bcopy(&info.dst_addr, &event_ibchanp->chan_local_addr,
		    sizeof (ibt_ip_addr_t));
		ipaddr2sockaddr(&info.dst_addr,
		    &(event_idp->route.addr.src_addr), &info.src_port);

		/*
		 * Increment number of Reqs for listening CMID,
		 * so that listening CMID is not deleted, till this
		 * connection expects no more events.
		 * chan_req_cnt is decremented connection is
		 * notified to the consumer.
		 *
		 * Insert the CMID into the REQ_AVL_TREE. This is
		 * deleted when the connection is accepted or rejected.
		 */
		mutex_enter(&root_chanp->chan_mutex);
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "Add to REQ AVL of %p IDP, idp %p, session_id %p",
		    root_idp, event_idp, event_chanp->chan_session_id);
		find_ret = avl_find(&root_chanp->chan_req_avl_tree,
		    (void *)event_chanp->chan_session_id, &where);
		if (find_ret) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "DUPLICATE ENTRY in REQ AVL : root %p, "
			    "idp %p, session_id %p",
			    root_idp, event_idp,
			    event_chanp->chan_session_id);
			mutex_exit(&root_chanp->chan_mutex);
			event_chanp->chan_req_state = REQ_CMID_CREATED;
			rdma_destroy_id(event_idp);
			return (IBT_CM_REJECT);
		}
		root_chanp->chan_req_cnt++;
		root_chanp->chan_req_state = REQ_CMID_CREATED;
		root_chanp->chan_req_total_cnt++;
		avl_insert(&root_chanp->chan_req_avl_tree,
		    (void *)event_idp, where);
		mutex_exit(&root_chanp->chan_mutex);

		event = RDMA_CM_EVENT_CONNECT_REQUEST;
		evt_status = 0;
	} else if (eventp->cm_type == IBT_CM_UD_EVENT_SIDR_REP) {
		ibt_cm_sidr_rep_t	*sidr_rep;

		ASSERT(chanp->chan_connect_flag == SOL_CMA_CONNECT_INITIATED);
		mutex_enter(&chanp->chan_mutex);
		chanp->chan_connect_flag = SOL_CMA_CONNECT_CLIENT_NONE;
		chanp->chan_cmid_destroy_state |= SOL_CMA_CALLER_EVENT_PROGRESS;
		mutex_exit(&chanp->chan_mutex);
		sidr_rep = &((eventp->cm_event).sidr_rep);
		if (sidr_rep->srep_status == IBT_CM_SREP_CHAN_VALID) {
			evt_status = 0;
			event = RDMA_CM_EVENT_ESTABLISHED;
			ud_paramp->qp_num = sidr_rep->srep_remote_qpn;
			ud_paramp->qkey = sidr_rep->srep_remote_qkey;
			ibt_path2ah(ibchanp->chan_pathp, &ud_paramp->ah_attr);
		} else {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "SIDR Response err with status %x",
			    sidr_rep->srep_status);
			event = RDMA_CM_EVENT_UNREACHABLE;
			evt_status = sidr_rep->srep_status;
			goto ud_gen_event;
		}
	}

	ud_paramp->private_data_len = cm_privlen;
	if (evt_status == 0 && cm_privlen) {
		ud_paramp->private_data = kmem_zalloc(cm_privlen, KM_SLEEP);
		bcopy(cm_priv, (void *)ud_paramp->private_data,
		    cm_privlen);
#ifdef DEBUG
		dump_priv_data((void *)ud_paramp->private_data,
		    SOL_REP_PRIV_DATA_SZ, cm_privlen, "ibcma_ud_hdlr");
#endif
	}

ud_gen_event:
	/* Pass back the event to sol_cma consumer */
	cma_generate_event(event_idp, event, evt_status, NULL, ud_paramp);

	if (ud_paramp->private_data)
		kmem_free((void *)ud_paramp->private_data, cm_privlen);

	if (eventp->cm_type == IBT_CM_UD_EVENT_SIDR_REQ)
		return (IBT_CM_DEFER);
	else
		return (IBT_CM_DEFAULT);
}

static ibt_cm_status_t
ibcma_handle_req(struct rdma_cm_id *idp, struct rdma_cm_id **event_id_ptr,
    ibt_cm_event_t *eventp, struct rdma_conn_param *paramp,
    enum rdma_cm_event_type *event, int *evt_status)
{
	struct rdma_cm_id	*root_idp, *event_idp;
	sol_cma_chan_t		*root_chanp, *event_chanp, *chanp;
	ibcma_chan_t		*event_ibchanp, *ibchanp;
	ibt_status_t		ibt_status;
	ibt_cm_req_rcv_t	*reqp;
	ibt_priv_data_len_t	cm_privlen;
	ibt_ofuvcm_req_data_t	rtr_data;
	ibt_ip_cm_info_t	info;
	void			*cm_priv, *priv_data;
	ib_lid_t		base_lid;
	void			*find_ret;
	avl_index_t		where;
	cma_chan_state_t	chan_state;
#ifdef  DEBUG
	void			*dump_priv;
#endif

	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;
	root_idp = CHAN_LISTEN_ROOT(chanp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	ASSERT(chanp->chan_listenp);
	ASSERT(root_idp);

	/*
	 * Reject further REQs if destroy of listen CMID
	 * has been called.
	 */
	mutex_enter(&root_chanp->chan_mutex);
	chan_state = cma_get_chan_state(root_chanp);
	mutex_exit(&root_chanp->chan_mutex);
	if (chan_state == SOL_CMA_CHAN_DESTROY_PENDING ||
	    chan_state == SOL_CMA_CHAN_DESTROY_WAIT) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "RC Req Hdlr, "
		    "listen CMID destroy called");
		return (IBT_CM_REJECT);
	}

	*event = RDMA_CM_EVENT_CONNECT_REQUEST;
	*evt_status = 0;
	reqp = &(eventp->cm_event.req);
	paramp->qp_num = reqp->req_remote_qpn;
	paramp->srq = (reqp->req_flags & IBT_CM_SRQ_EXISTS) ? 1 : 0;
	paramp->responder_resources = reqp->req_rdma_ra_in;
	paramp->initiator_depth = reqp->req_rdma_ra_out;
	paramp->flow_control = (reqp->req_flags & IBT_CM_FLOW_CONTROL)
	    ? 1 : 0;
	paramp->retry_count = reqp->req_retry_cnt;
	paramp->rnr_retry_count = reqp->req_rnr_retry_cnt;

#ifdef	DEBUG
	dump_priv = kmem_zalloc(SOL_REQ_PRIV_DATA_SZ, KM_SLEEP);
	bcopy(eventp->cm_priv_data, dump_priv, eventp->cm_priv_data_len);
	dump_priv_data(dump_priv, SOL_REQ_PRIV_DATA_SZ,
	    eventp->cm_priv_data_len, "handle_req");
	kmem_free(dump_priv, SOL_REQ_PRIV_DATA_SZ);
#endif	/* DEBUG */

	cm_privlen = eventp->cm_priv_data_len;
	cm_priv = eventp->cm_priv_data;
	if (cm_privlen < IBT_IP_HDR_PRIV_DATA_SZ) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "RC Req Hdlr, "
		    "Priv data len %x < %x", cm_privlen,
		    IBT_IP_HDR_PRIV_DATA_SZ);
		return (IBT_CM_REJECT);
	}
	ibt_status = ibt_get_ip_data(cm_privlen, cm_priv, &info);
	if (ibt_status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "RC Req Hdlr, "
		    "ibt_get_ip_data failed, %x", ibt_status);
		return (IBT_CM_REJECT);
	}
	bcopy(&info.dst_addr, &ibchanp->chan_remote_addr,
	    sizeof (ibt_ip_addr_t));

	ibt_status = ibt_ofuvcm_get_req_data(eventp->cm_session_id, &rtr_data);
	if (ibt_status != IBT_SUCCESS) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "RC Req Hdlr, "
		    "ibt_ofuvcm_get_req_data failed, %x", ibt_status);
		return (IBT_CM_REJECT);
	}

	paramp->private_data_len = cm_privlen - IBT_IP_HDR_PRIV_DATA_SZ;
	if (paramp->private_data_len) {
		priv_data = (void *)((uint8_t *)cm_priv +
		    IBT_IP_HDR_PRIV_DATA_SZ);
		paramp->private_data = kmem_zalloc(paramp->private_data_len,
		    KM_SLEEP);
		bcopy(priv_data, (void *)paramp->private_data,
		    paramp->private_data_len);
	}
	event_idp = ibcma_create_new_id(idp);
	if (event_idp == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "create_new_id failed!!");
		if (paramp->private_data)
			kmem_free((void *)paramp->private_data,
			    paramp->private_data_len);
		return (IBT_CM_REJECT);
	}

	/*
	 * Fill the route, device and port_num.
	 * TBD - Fill up packet_life_time
	 */
	event_idp->device = sol_cma_acquire_device(ntohll(
	    reqp->req_hca_guid));
	event_idp->port_num = reqp->req_prim_hca_port;
	(event_idp->route).num_paths = reqp->req_alt_hca_port ? 2 : 1;
	event_idp->route.path_rec = kmem_zalloc(
	    sizeof (struct ib_sa_path_rec) * ((event_idp->route).num_paths),
	    KM_SLEEP);
	base_lid = ibt_get_port_state_byguid(reqp->req_hca_guid,
	    reqp->req_prim_hca_port, NULL, &base_lid);
	ibt_addsvect2sa_path(&reqp->req_prim_addr,
	    &(event_idp->route.path_rec[0]), base_lid);
	(event_idp->route.path_rec[0]).mtu = (uint8_t)rtr_data.req_path_mtu;
	if (reqp->req_alt_hca_port) {
		base_lid = ibt_get_port_state_byguid(
		    reqp->req_hca_guid, reqp->req_alt_hca_port,
		    NULL, &base_lid);
		ibt_addsvect2sa_path(&reqp->req_alt_addr,
		    &(event_idp->route.path_rec[1]), base_lid);
		(event_idp->route.path_rec[1]).mtu =
		    (uint8_t)rtr_data.req_path_mtu;
	}

	*event_id_ptr = event_idp;

	event_chanp = (sol_cma_chan_t *)event_idp;
	event_chanp->chan_req_state = REQ_CMID_NOTIFIED;
	event_ibchanp = &event_chanp->chan_ib;
	event_chanp->chan_session_id = eventp->cm_session_id;
	bcopy((void *)(&reqp->req_prim_addr),
	    (void *)(&event_ibchanp->chan_rcreq_addr),
	    sizeof (ibt_adds_vect_t));
	bcopy(&rtr_data, &(event_ibchanp->chan_rtr_data),
	    sizeof (ibt_ofuvcm_req_data_t));
	event_ibchanp->chan_rcreq_qpn = reqp->req_remote_qpn;
	event_ibchanp->chan_rcreq_ra_in = reqp->req_rdma_ra_in;
	bcopy(&info.src_addr, &event_ibchanp->chan_remote_addr,
	    sizeof (ibt_ip_addr_t));
	ipaddr2sockaddr(&info.src_addr,
	    &(event_idp->route.addr.dst_addr), &info.src_port);
	bcopy(&info.dst_addr, &event_ibchanp->chan_local_addr,
	    sizeof (ibt_ip_addr_t));
	ipaddr2sockaddr(&info.dst_addr,
	    &(event_idp->route.addr.src_addr), &info.src_port);

	/*
	 * Increment number of Reqs for listening CMID, so that
	 * listening CMID is not deleted, till this connection
	 * expects no more events. chan_req_cnt is decremented
	 * when connection is notified to the consumer.
	 *
	 * Insert the CMID into the REQ_AVL_TREE. This is
	 * deleted when the connection is accepted or rejected.
	 */
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "Add to REQ AVL of %p IDP, idp %p, session_id %p",
	    root_idp, event_idp, event_chanp->chan_session_id);
	mutex_enter(&root_chanp->chan_mutex);
	find_ret = avl_find(&root_chanp->chan_req_avl_tree,
	    (void *)event_chanp->chan_session_id, &where);
	if (find_ret) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "DUPLICATE ENTRY in REQ AVL : root %p, "
		    "idp %p, session_id %p",
		    root_idp, event_idp,
		    event_chanp->chan_session_id);
		mutex_exit(&root_chanp->chan_mutex);
		event_chanp->chan_req_state = REQ_CMID_CREATED;
		if (paramp->private_data)
			kmem_free((void *)paramp->private_data,
			    paramp->private_data_len);
		rdma_destroy_id(event_idp);
		return (IBT_CM_REJECT);
	}
	root_chanp->chan_req_cnt++;
	root_chanp->chan_req_state = REQ_CMID_CREATED;
	root_chanp->chan_req_total_cnt++;

	avl_insert(&root_chanp->chan_req_avl_tree, (void *)event_idp, where);
	mutex_exit(&root_chanp->chan_mutex);

	return (IBT_CM_DEFER);
}

static void
ibcma_handle_rep(struct rdma_cm_id *idp, ibt_cm_event_t *eventp)
{
	sol_cma_chan_t		*chanp;
	ibt_cm_rep_rcv_t	*repp;
	struct rdma_conn_param	*paramp;

	chanp = (sol_cma_chan_t *)idp;

	paramp = &chanp->chan_param;
	bzero(paramp, sizeof (chanp->chan_param));
	repp = &((eventp->cm_event).rep);
	paramp->srq = (repp->rep_flags & IBT_CM_SRQ_EXISTS) ? 1 : 0;
	paramp->responder_resources = repp->rep_rdma_ra_in;
	paramp->initiator_depth = repp->rep_rdma_ra_out;
	paramp->flow_control = (repp->rep_flags & IBT_CM_FLOW_CONTROL) ? 1 : 0;

#ifdef DEBUG
	dump_priv_data(eventp->cm_priv_data, SOL_REP_PRIV_DATA_SZ,
	    eventp->cm_priv_data_len, "handle_rep");
#endif
	paramp->private_data_len =  eventp->cm_priv_data_len;
	if (paramp->private_data_len) {
		paramp->private_data = kmem_zalloc(paramp->private_data_len,
		    KM_SLEEP);
		bcopy((void *)eventp->cm_priv_data,
		    (void *)paramp->private_data, paramp->private_data_len);
	}
}

static ibt_cm_status_t
ibcma_handle_est(struct rdma_cm_id *idp, struct rdma_cm_id **event_id_ptr,
    ibt_cm_event_t *eventp, struct rdma_conn_param *paramp,
    enum rdma_cm_event_type *event, int *evt_status)
{
	struct rdma_cm_id	*event_idp, *root_idp;
	sol_cma_chan_t		*event_chanp, *chanp, *root_chanp;
	ibcma_chan_t		*event_ibchanp;

	/* Established event on active / client side */
	chanp = (sol_cma_chan_t *)idp;
	if (chanp->chan_listenp == NULL) {
		ASSERT(chanp->chan_connect_flag == SOL_CMA_CONNECT_INITIATED);
		chanp->chan_connect_flag = SOL_CMA_CONNECT_ESTABLISHED;
		*event_id_ptr = idp;
		bcopy(&chanp->chan_param, paramp,
		    sizeof (struct rdma_conn_param));
		if (paramp->private_data_len) {
			paramp->private_data = kmem_zalloc(
			    paramp->private_data_len, KM_SLEEP);
			bcopy((void *)((chanp->chan_param).private_data),
			    (void *)paramp->private_data,
			    paramp->private_data_len);
			kmem_free((void *)((chanp->chan_param).private_data),
			    paramp->private_data_len);
		}
		event_chanp = chanp;
		mutex_enter(&chanp->chan_mutex);
		chanp->chan_cmid_destroy_state |= SOL_CMA_CALLER_EVENT_PROGRESS;
		mutex_exit(&chanp->chan_mutex);
		goto est_common;
	}

	root_idp = CHAN_LISTEN_ROOT((chanp));
	ASSERT(root_idp);
	root_chanp = (sol_cma_chan_t *)root_idp;
	event_chanp = NULL;

	mutex_enter(&root_chanp->chan_mutex);
	event_idp = cma_get_acpt_idp(root_idp, eventp->cm_channel);
	mutex_exit(&root_chanp->chan_mutex);
	if (event_idp == NULL) {
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str, "ibcma_handle_est: "
		    "No matching CMID for qp_hdl %p in ACPT AVL of CMID %p",
		    eventp->cm_channel, root_chanp);
		return (IBT_CM_REJECT);
	}
	*event_id_ptr = event_idp;
	event_chanp = (sol_cma_chan_t *)event_idp;
	mutex_enter(&event_chanp->chan_mutex);
	event_chanp->chan_cmid_destroy_state |=
	    SOL_CMA_CALLER_EVENT_PROGRESS;
	mutex_exit(&event_chanp->chan_mutex);

est_common:
#ifdef QP_DEBUG
	dump_qp_info(event_chanp->chan_qp_hdl);
#endif

	/*
	 * Pass back CONNECT_ESTABLISHED event to consumer.
	 */
	*event = RDMA_CM_EVENT_ESTABLISHED;
	event_ibchanp = &event_chanp->chan_ib;
	event_ibchanp->chan_qpmodifyflag  = 1;

	*evt_status = 0;
	return (IBT_CM_DEFAULT);
}

static ibt_cm_status_t
ibcma_handle_closed(struct rdma_cm_id *idp, struct rdma_cm_id **event_id_ptr,
    ibt_cm_event_t *eventp, enum rdma_cm_event_type *event, int *evt_status)
{
	struct rdma_cm_id	*root_idp, *event_idp;
	sol_cma_chan_t		*chanp, *root_chanp, *event_chanp;

	*event = RDMA_CM_EVENT_DISCONNECTED;
	*evt_status = 0;
	chanp = (sol_cma_chan_t *)idp;
	mutex_enter(&chanp->chan_mutex);
	root_idp = CHAN_LISTEN_ROOT((chanp));
	root_chanp = (sol_cma_chan_t *)root_idp;
	chanp->chan_qp_hdl = NULL;
	if (!root_idp) {
		chanp->chan_cmid_destroy_state |=
		    SOL_CMA_CALLER_EVENT_PROGRESS;
		chanp->chan_qp_hdl = NULL;
		chanp->chan_connect_flag = SOL_CMA_CONNECT_CLIENT_NONE;
		mutex_exit(&chanp->chan_mutex);
		*event_id_ptr = idp;
		return (IBT_CM_DEFAULT);
	}
	mutex_exit(&chanp->chan_mutex);

	/* On the passive side, search ACPT AVL Tree */
	mutex_enter(&root_chanp->chan_mutex);
	event_idp = cma_get_acpt_idp(root_idp, eventp->cm_channel);
	event_chanp = (sol_cma_chan_t *)event_idp;
	if (event_idp == NULL) {
		mutex_exit(&root_chanp->chan_mutex);
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_handle_closed: "
		    "No matching CMID for qp hdl %p in EST AVL of CMID %p",
		    eventp->cm_channel, root_idp);
		return (IBT_CM_DEFAULT);
	}
	avl_remove(&root_chanp->chan_acpt_avl_tree, event_idp);
	mutex_exit(&root_chanp->chan_mutex);
	mutex_enter(&event_chanp->chan_mutex);
	event_chanp->chan_req_state = REQ_CMID_SERVER_NONE;
	event_chanp->chan_cmid_destroy_state |=
	    SOL_CMA_CALLER_EVENT_PROGRESS;
	mutex_exit(&event_chanp->chan_mutex);

	*event_id_ptr = event_idp;
	return (IBT_CM_DEFAULT);
}

static ibt_cm_status_t
ibcma_handle_failed(struct rdma_cm_id *idp, struct rdma_cm_id **event_id_ptr,
    ibt_cm_event_t *eventp, struct rdma_conn_param *paramp,
    enum rdma_cm_event_type *event, int *evt_status)
{
	struct rdma_cm_id	*root_idp, *event_idp;
	sol_cma_chan_t		*event_chanp, *chanp, *root_chanp;
	ibt_cm_conn_failed_t	*failedp;

	failedp = &(eventp->cm_event.failed);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "ibcma_handle_failed - idp %p, "
	    "cf_code %x, cf_msg %x, cf_arej_info_valid %x, cf_reason %x",
	    idp, failedp->cf_code, failedp->cf_msg,
	    failedp->cf_arej_info_valid, failedp->cf_reason);
	chanp = (sol_cma_chan_t *)idp;
	root_idp = CHAN_LISTEN_ROOT((chanp));
	root_chanp = (sol_cma_chan_t *)root_idp;

	*evt_status = 0;
	switch (failedp->cf_code) {
	case IBT_CM_FAILURE_REJ_SENT :
		/*  Reject sent. No event to userland. */
		break;

	case IBT_CM_FAILURE_REJ_RCV :
		/*
		 * Reject recieved. If this is a consumer reject, copy the
		 * private * data. Send RDMA_CM_EVENT_REJECTED to user land.
		 */
		if (failedp->cf_reason == IBT_CM_CONSUMER &&
		    eventp->cm_priv_data_len) {
			paramp->private_data_len = eventp->cm_priv_data_len;
			paramp->private_data = kmem_zalloc(
			    paramp->private_data_len, KM_SLEEP);
			bcopy(eventp->cm_priv_data,
			    (void *)paramp->private_data,
			    paramp->private_data_len);
		}

		/*
		 * If this an REJECT for an accepted CMID, pass the
		 * event to accepted CMID.
		 */
		if (root_idp) {
			sol_cma_chan_t	*root_chanp;
			ASSERT(eventp->cm_channel);

			root_chanp = (sol_cma_chan_t *)root_idp;
			mutex_enter(&root_chanp->chan_mutex);
			event_idp = cma_get_acpt_idp(root_idp,
			    eventp->cm_channel);
			if (event_idp == NULL) {
				SOL_OFS_DPRINTF_L3(sol_rdmacm_dbg_str,
				    "ibcma_handle_failed: No matching CMID "
				    "for qp_hdl %p in ACPT AVL of CMID %p",
				    eventp->cm_channel, idp);
				mutex_exit(&root_chanp->chan_mutex);
				break;
			}

			event_chanp = (sol_cma_chan_t *)event_idp;
			*event_id_ptr = event_idp;
			mutex_enter(&event_chanp->chan_mutex);
			avl_remove(&root_chanp->chan_acpt_avl_tree,
			    event_idp);
			event_chanp->chan_req_state = REQ_CMID_SERVER_NONE;
			event_chanp->chan_cmid_destroy_state |=
			    SOL_CMA_CALLER_EVENT_PROGRESS;
			event_chanp->chan_qp_hdl = NULL;
			mutex_exit(&event_chanp->chan_mutex);
			mutex_exit(&root_chanp->chan_mutex);
		} else {
			mutex_enter(&chanp->chan_mutex);
			chanp->chan_cmid_destroy_state |=
			    SOL_CMA_CALLER_EVENT_PROGRESS;
			chanp->chan_qp_hdl = NULL;
			chanp->chan_connect_flag =
			    SOL_CMA_CONNECT_CLIENT_NONE;
			mutex_exit(&chanp->chan_mutex);
			*event_id_ptr  = idp;
		}
		*evt_status = failedp->cf_reason;
		*event = RDMA_CM_EVENT_REJECTED;
		break;

	case IBT_CM_FAILURE_TIMEOUT :
		/*
		 * Connection Timeout, Send RDMA_CM_EVENT_REJECTED event and
		 * status as IBT_CM_TIMEOUT.
		 */
		if (eventp->cm_session_id && root_idp) {
			mutex_enter(&root_chanp->chan_mutex);
			event_idp = cma_get_req_idp(root_idp,
			    eventp->cm_session_id);
			if (event_idp == NULL) {
				mutex_exit(&root_chanp->chan_mutex);
				SOL_OFS_DPRINTF_L3(sol_rdmacm_dbg_str,
				    "ibcma_handle_failed: No matching CMID "
				    "for qp_hdl %p in REQ AVL of CMID %p",
				    eventp->cm_session_id, idp);
				break;
			}

			event_chanp = (sol_cma_chan_t *)event_idp;
			mutex_enter(&event_chanp->chan_mutex);
			*event_id_ptr = event_idp;
			avl_remove(&root_chanp->chan_req_avl_tree,
			    event_idp);
			root_chanp->chan_req_cnt--;
			event_chanp->chan_req_state = REQ_CMID_SERVER_NONE;
			event_chanp->chan_qp_hdl = NULL;
			mutex_exit(&event_chanp->chan_mutex);
			mutex_exit(&root_chanp->chan_mutex);


			*evt_status = IBT_CM_TIMEOUT;
			*event = RDMA_CM_EVENT_REJECTED;
		}
		if (!eventp->cm_session_id && root_idp) {
			SOL_OFS_DPRINTF_L0(sol_rdmacm_dbg_str,
			    "ibcma_handle_failed: timeout "
			    "session_id NULL");
		}
		if (!root_idp) {
			*event_id_ptr  = idp;
			mutex_enter(&chanp->chan_mutex);
			chanp->chan_cmid_destroy_state |=
			    SOL_CMA_CALLER_EVENT_PROGRESS;
			chanp->chan_qp_hdl = NULL;
			chanp->chan_connect_flag =
			    SOL_CMA_CONNECT_CLIENT_NONE;
			mutex_exit(&chanp->chan_mutex);
			*evt_status = IBT_CM_TIMEOUT;
			*event = RDMA_CM_EVENT_REJECTED;
		}
		break;

	case IBT_CM_FAILURE_STALE :
		/* Stale connection, ignore */
		break;
	}
	return (IBT_CM_DEFAULT);
}

static ibt_cm_status_t
ibcma_rc_hdlr(void *inp, ibt_cm_event_t *eventp,
    ibt_cm_return_args_t *ret_args, void *priv_data,
    ibt_priv_data_len_t priv_datalen)
{
	struct rdma_cm_id	*idp, *event_idp;
	sol_cma_chan_t		*chanp;
	ibt_cm_status_t		status;
	ibt_status_t		ibt_status;
	enum rdma_cm_event_type event;
	struct rdma_conn_param	conn_param, *paramp = &conn_param;
	int	event_status;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "ib_cma_rc_hdlr(%p, %p, %p, "
	    "%p, %x)", inp, eventp, ret_args, priv_data, priv_datalen);
	idp = event_idp = (struct rdma_cm_id *)inp;
	chanp = (sol_cma_chan_t *)idp;
	chanp->chan_session_id = NULL;

	bzero(paramp, sizeof (struct rdma_conn_param));
	switch (eventp->cm_type) {

	case IBT_CM_EVENT_REQ_RCV :
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : REQ Event");

		/*
		 * We need to do a round trip to userland. Send a MRA
		 * so that the client does not send multiple REQs. Then
		 * continue the processing of REQs.
		 */
		ibt_status =  ibt_cm_delay(IBT_CM_DELAY_REQ,
		    eventp->cm_session_id, SOL_OFS_REQ_DELAY, NULL, 0);
		if (ibt_status != IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "ibcma_rc_hdlr : ibt_cma_delay failed %x",
			    ibt_status);
			return (IBT_CM_REJECT);
		}
		status = ibcma_handle_req(idp, &event_idp, eventp, paramp,
		    &event, &event_status);
		if (status == IBT_CM_REJECT)
			return (status);
		break;
	case IBT_CM_EVENT_REP_RCV :
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : REP Event");

		ibcma_handle_rep(idp, eventp);
		return (IBT_CM_DEFAULT);
		/* NOTREACHED */
		/* break; */
	case IBT_CM_EVENT_LAP_RCV :
	case IBT_CM_EVENT_APR_RCV :
		/*
		 * Alternate Paths not supported from userland. Return
		 * IBT_CM_REJECT.
		 */
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : AP Event");
		return (IBT_CM_REJECT);
		/* NOTREACHED */
		/* break; */
	case IBT_CM_EVENT_MRA_RCV :
		/* Let Solaris ibcm take default action for MRA */
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : MRA Event");
		return (IBT_CM_DEFAULT);
		/* NOTREACHED */
		/* break; */
	case IBT_CM_EVENT_CONN_EST :
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : EST Event");
		status = ibcma_handle_est(idp, &event_idp, eventp, paramp,
		    &event, &event_status);
		break;
	case IBT_CM_EVENT_CONN_CLOSED :
		/*
		 * Pass on RDMA_CM_EVENT_DISCONNECTED to consumer
		 */
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : CLOSED Event");
		status = ibcma_handle_closed(idp, &event_idp, eventp,
		    &event, &event_status);
		break;

	case IBT_CM_EVENT_FAILURE :
		/* Handle Failure Event */
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "ibcma_rc_hdlr : FAIL Event");
		status = ibcma_handle_failed(idp, &event_idp, eventp, paramp,
		    &event, &event_status);

		/*
		 * Check if there is an event to be send to the userland.
		 * Return if there are none.
		 */
		if (event_status == 0)
			return (status);
		break;
	}

	/* Pass back the event to sol_cma consumer */
	if (event_idp) {
		cma_generate_event(event_idp, event, event_status,
		    paramp, NULL);
	} else
		SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
		    "No Event to userland!!");
	if (paramp->private_data)
		kmem_free((void *)paramp->private_data,
		    paramp->private_data_len);

	return (status);
}

static void
ibcma_multicast_hdlr(void *arg, ibt_status_t status, ibt_mcg_info_t *mcg_infop)
{
	struct rdma_cm_id	*idp;
	ibcma_mcast_t		*ib_mcastp = (ibcma_mcast_t *)arg;
	int			evt_status;
	struct rdma_ud_param	uddata, *ud_param = &uddata;
	enum rdma_cm_event_type event;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "multicast_hdlr(%p, %x, %p)",
	    arg, status, mcg_infop);
	idp = ib_mcastp->mcast_idp;

	bzero(ud_param, sizeof (struct rdma_ud_param));
	bcopy(&(mcg_infop->mc_adds_vect.av_dgid),
	    &(ib_mcastp->mcast_gid), sizeof (ib_gid_t));
	ud_param->private_data = ib_mcastp->mcast_ctx;

	event = (status == IBT_SUCCESS) ?
	    RDMA_CM_EVENT_MULTICAST_JOIN : RDMA_CM_EVENT_MULTICAST_ERROR;
	evt_status = (status == IBT_SUCCESS) ? 0 : -1;
	if (status == IBT_SUCCESS) {
		mcginfo2ah(mcg_infop, &ud_param->ah_attr);
		ud_param->qp_num = IB_MC_QPN;
		if (idp->ps == RDMA_PS_UDP)
			ud_param->qkey = RDMA_UDP_QKEY;
		else
			ud_param->qkey = SOL_IPOIB_DEFAULT_QKEY;
	}

	/* Send the event to consumer of sol_cma.  */
	cma_generate_event(idp, event, evt_status, NULL, ud_param);
	kmem_free(mcg_infop, sizeof (ibt_mcg_info_t));
}

static int
ibcma_get_first_ib_ipaddr(struct rdma_cm_id *idp)
{
	sol_cma_chan_t	*chanp = (sol_cma_chan_t *)idp;
	ibcma_chan_t	*ibchanp;
	int		num_hcas, info_inited = 0;
	ib_guid_t	*hca_guidp;
	genlist_t	devlist;
	genlist_entry_t	*entry;
	ibcma_dev_t	*devp;

	ASSERT(idp);
	ibchanp = &(chanp->chan_ib);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "get_first_ib_ipaddr(%p)", idp);

	num_hcas = ibt_get_hca_list(&hca_guidp);
	ibcma_get_devlist(chanp, hca_guidp, num_hcas, &devlist, B_TRUE);
	entry = remove_genlist_head(&devlist);
	while (entry) {
		devp = (ibcma_dev_t *)entry->data;
		if (info_inited == 0) {
			(idp->route).num_paths = 0;
			idp->port_num = devp->dev_port_num;
			chanp->chan_xport_type = SOL_CMA_XPORT_IB;
			ibchanp->chan_devp = devp;
			info_inited = 1;
		} else {
			kmem_free(devp, sizeof (ibcma_dev_t));
		}
		kmem_free(entry, sizeof (genlist_entry_t));
		entry = remove_genlist_head(&devlist);
	}
	ibt_free_hca_list(hca_guidp, num_hcas);

	if (info_inited)
		return (0);
	else
		return (ENODEV);
}

/* Utility Conversion functions */
static void
ipaddr2sockaddr(ibt_ip_addr_t *ibt_addrp, struct sockaddr *sock_addrp,
    in_port_t *portp)
{
		sock_addrp->sa_family = ibt_addrp->family;
		if (ibt_addrp->family == AF_INET) {
			struct sockaddr_in	*sock_in4p;
			sock_in4p = (struct sockaddr_in *)sock_addrp;

			sock_in4p->sin_addr.s_addr = ibt_addrp->un.ip4addr;
			if (portp)
				sock_in4p->sin_port = ntohs(*portp);
		} else {
			struct sockaddr_in6 *in6_addr;
			in6_addr = (struct sockaddr_in6 *)sock_addrp;

			bcopy(&(ibt_addrp->un.ip6addr), &(in6_addr->sin6_addr),
			    sizeof (in6_addr_t));
			if (portp)
				in6_addr->sin6_port = *portp;
		}
}

static void
sockaddr2ibtaddr_port(struct rdma_cm_id *idp, struct sockaddr *sock_addrp,
    ibt_ip_addr_t *ibt_addrp, in_port_t *portp)
{
	in_port_t	ip_port;

	ibt_addrp->family = sock_addrp->sa_family;
	if (sock_addrp->sa_family == AF_INET) {
		struct sockaddr_in	*sock_in4p;
		sock_in4p = (struct sockaddr_in *)sock_addrp;

		ibt_addrp->un.ip4addr = sock_in4p->sin_addr.s_addr;
		if (IS_UDP_CMID(idp))
			ip_port = ddi_swap16(sock_in4p->sin_port);
		else
			ip_port = htons(sock_in4p->sin_port);

		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "sockaddr2ibtaddr : "
		    "AF_INET addr %x, port %x, %x", ibt_addrp->un.ip4addr,
		    sock_in4p->sin_port, ip_port);

		if (portp)
			*portp = ip_port;

	} else {
		struct sockaddr_in6	*in6_addr;
		in6_addr = (struct sockaddr_in6 *)sock_addrp;
		bcopy(&(in6_addr->sin6_addr), &(ibt_addrp->un.ip6addr),
		    sizeof (in6_addr_t));
		if (portp)
			*portp = in6_addr->sin6_port;
	}
}

static void
mcginfo2ah(ibt_mcg_info_t *mcgp, struct ib_ah_attr *ah_attr)
{
	ibt_adds_vect_t	*adds_vectp;
	ib_gid_t	dgid_nworder;

	adds_vectp = &(mcgp->mc_adds_vect);

	/*
	 * Libraries expect the GID to be in network order. Convert
	 * to network order before passing it to the library.
	 */
	dgid_nworder.gid_prefix = htonll(
	    (adds_vectp->av_dgid).gid_prefix);
	dgid_nworder.gid_guid = htonll(
	    (adds_vectp->av_dgid).gid_guid);
	bcopy(&dgid_nworder, &((ah_attr->grh).dgid), sizeof (ib_gid_t));

	(ah_attr->grh).flow_label =  adds_vectp->av_flow;
	(ah_attr->grh).sgid_index = adds_vectp->av_sgid_ix;
	(ah_attr->grh).hop_limit = adds_vectp->av_hop;
	(ah_attr->grh).traffic_class = adds_vectp->av_tclass;

	ah_attr->dlid = adds_vectp->av_dlid;
	ah_attr->sl = adds_vectp->av_srvl;
	ah_attr->src_path_bits = adds_vectp->av_src_path;
	ah_attr->static_rate = adds_vectp->av_srate;
	ah_attr->ah_flags = (adds_vectp->av_send_grh) ? 1 : 0;
	ah_attr->port_num = adds_vectp->av_port_num;
}

static void
ibt_path2ah(ibt_path_info_t *pathp, struct ib_ah_attr *ah_attr)
{

	ibt_addsvect2ah(&((pathp->pi_prim_cep_path).cep_adds_vect), ah_attr);
}

static void
ibt_addsvect2ah(ibt_adds_vect_t *adds_vectp, struct ib_ah_attr *ah_attr)
{
	ib_gid_t	dgid_nworder;

	/*
	 * Libraries expect the GID to be in network order. Convert
	 * to network order before passing it to the library.
	 */
	dgid_nworder.gid_prefix = htonll(
	    (adds_vectp->av_dgid).gid_prefix);
	dgid_nworder.gid_guid = htonll(
	    (adds_vectp->av_dgid).gid_guid);
	bcopy(&dgid_nworder, &((ah_attr->grh).dgid), sizeof (ib_gid_t));
	(ah_attr->grh).flow_label =  adds_vectp->av_flow;
	(ah_attr->grh).sgid_index = adds_vectp->av_sgid_ix;
	(ah_attr->grh).hop_limit = adds_vectp->av_hop;
	(ah_attr->grh).traffic_class = adds_vectp->av_tclass;

	ah_attr->dlid = adds_vectp->av_dlid;
	ah_attr->sl = adds_vectp->av_srvl;
	ah_attr->src_path_bits = adds_vectp->av_src_path;
	ah_attr->static_rate = adds_vectp->av_srate;
	ah_attr->ah_flags = (adds_vectp->av_send_grh) ? 1 : 0;
	ah_attr->port_num = adds_vectp->av_port_num;
}

static void
ibt_path2sa_path(ibt_path_info_t *pathp, struct ib_sa_path_rec *sa_pathp,
    ib_lid_t base_lid)
{
	ibt_adds_vect_t	*adds_vectp;

	adds_vectp = &((pathp->pi_prim_cep_path).cep_adds_vect);
	ibt_addsvect2sa_path(adds_vectp, sa_pathp, base_lid);
	sa_pathp->mtu = pathp->pi_path_mtu;
	sa_pathp->packet_life_time = pathp->pi_prim_pkt_lt;
}

static void
ibt_addsvect2sa_path(ibt_adds_vect_t *adds_vectp,
    struct ib_sa_path_rec *sa_pathp, ib_lid_t base_lid)
{
	bcopy(&(adds_vectp->av_dgid), &(sa_pathp->dgid), 16);
	bcopy(&(adds_vectp->av_sgid), &(sa_pathp->sgid), 16);
	sa_pathp->dlid = adds_vectp->av_dlid;
	sa_pathp->slid = base_lid + adds_vectp->av_src_path;
	sa_pathp->flow_label =  adds_vectp->av_flow;
	sa_pathp->reversible = 1;
	sa_pathp->hop_limit = adds_vectp->av_hop;
	sa_pathp->traffic_class  = adds_vectp->av_tclass;
	sa_pathp->sl = adds_vectp->av_srvl;
	sa_pathp->rate = adds_vectp->av_srate;
	sa_pathp->mtu_selector = IBT_EQU;
	sa_pathp->rate_selector = IBT_EQU;
	sa_pathp->packet_life_time_selector = IBT_EQU;
}

/*
 * Map a multicast IP onto multicast MAC for type IP-over-InfiniBand.
 * Leave P_Key as 0 to be filled in by caller
 */
static void
ip_ib_mc_map(uint32_t addr, char *buf)
{
	buf[0]  = 0;		/* Reserved */
	buf[1]  = 0xff;		/* Multicast QPN */
	buf[2]  = 0xff;
	buf[3]  = 0xff;
	addr    = ntohl(addr);
	buf[4]  = 0xff;
	buf[5]  = 0x12;		/* link local scope */
	buf[6]  = 0x40;		/* IPv4 signature */
	buf[7]  = 0x1b;
	buf[8]  = 0;		/* P_Key */
	buf[9]  = 0;
	buf[10] = 0;
	buf[11] = 0;
	buf[12] = 0;
	buf[13] = 0;
	buf[14] = 0;
	buf[15] = 0;
	buf[19] = addr & 0xff;
	addr  >>= 8;
	buf[18] = addr & 0xff;
	addr  >>= 8;
	buf[17] = addr & 0xff;
	addr  >>= 8;
	buf[16] = addr & 0x0f;
}

static void
ipaddr2mgid(struct sockaddr *addrp, ib_gid_t *mgidp, ib_pkey_t pkey)
{
	char			mc_map[32];	/* Max H/W addr len */
	struct sockaddr_in	*sin = (struct sockaddr_in *)addrp;
	struct sockaddr_in6	*sin6 = (struct sockaddr_in6 *)addrp;

	if ((addrp->sa_family ==  AF_INET6) &&
	    b2h32((sin6->sin6_addr.s6_addr32[0]) & 0xFF10A01B) ==
	    0xFF10A01B) {
		bcopy(&sin6->sin6_addr, mgidp, sizeof (ib_gid_t));
	} else {
		ip_ib_mc_map(sin->sin_addr.s_addr, mc_map);
		mc_map[7] = 0x01;   /* Use RDMA CM signature */
		mc_map[8] = (char)(pkey >> 8);
		mc_map[9] = (char)(pkey);
		bcopy(mc_map+4, mgidp, sizeof (ib_gid_t));
	}
}

static int
ibcma_any_addr(ibt_ip_addr_t *addr)
{
	ASSERT(addr);
	if (addr->family == AF_INET)
		return (addr->un.ip4addr == INADDR_ANY);
	else if (addr->family == AF_INET6)
		return (IN6_IS_ADDR_UNSPECIFIED(&(addr->un.ip6addr)));
	return (0);
}

static struct rdma_cm_id *
ibcma_create_new_id(struct rdma_cm_id *idp)
{
	struct rdma_cm_id	*new_idp;
	sol_cma_chan_t		*chanp, *new_chanp;
	ibcma_chan_t		*ibchanp, *new_ibchanp;

	new_idp = cma_create_new_id(idp);
	if (new_idp == NULL)
		return (new_idp);
	new_chanp = (sol_cma_chan_t *)new_idp;
	new_ibchanp = &new_chanp->chan_ib;
	chanp = (sol_cma_chan_t *)idp;
	ibchanp = &chanp->chan_ib;
	if (ibchanp->chan_devp) {
		ibcma_dev_t	*devp;

		devp = (ibcma_dev_t *)kmem_zalloc(sizeof (ibcma_dev_t),
		    KM_SLEEP);
		new_ibchanp->chan_devp = devp;
		bcopy(ibchanp->chan_devp, devp, sizeof (ibcma_dev_t));
	}

	if (ibchanp->chan_pathp && ibchanp->chan_numpaths &&
	    ibchanp->chan_path_size) {
		new_ibchanp->chan_pathp = (ibt_path_info_t *)kmem_zalloc(
		    ibchanp->chan_path_size, KM_SLEEP);
		bcopy(ibchanp->chan_pathp, new_ibchanp->chan_pathp,
		    ibchanp->chan_path_size);
		new_ibchanp->chan_path_size = ibchanp->chan_path_size;
		new_ibchanp->chan_numpaths = ibchanp->chan_numpaths;
	}
	bcopy(&ibchanp->chan_local_addr, &new_ibchanp->chan_local_addr,
	    sizeof (ibt_ip_addr_t));
	bcopy(&ibchanp->chan_remote_addr, &new_ibchanp->chan_remote_addr,
	    sizeof (ibt_ip_addr_t));
	new_ibchanp->chan_port = ibchanp->chan_port;
	new_ibchanp->chan_sid = ibchanp->chan_sid;

	return (new_idp);
}

static void
ibcma_get_devlist(sol_cma_chan_t *root_chanp, ib_guid_t *hca_guidp,
    int num_hcas, genlist_t *ret_devlist, boolean_t with_ipaddr_only)
{
	int			i;
	ibt_status_t		status;
	ibcma_dev_t		*devp;
	uint_t			num_ports, p;
	uint_t			port_size;
	ibt_hca_portinfo_t	*port_info, *tmp;
	ibt_srcip_info_t	*src_info;
	ibt_srcip_attr_t	attr;
	uint_t			entries;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "get_devlist(%p, %p, %x, %p, %x)", root_chanp, hca_guidp,
	    num_hcas, ret_devlist, with_ipaddr_only);

	init_genlist(ret_devlist);
	for (i = 0; i < num_hcas; i++) {
		status = ibt_query_hca_ports_byguid(hca_guidp[i], 0, &port_info,
		    &num_ports, &port_size);
		if (status !=  IBT_SUCCESS) {
			SOL_OFS_DPRINTF_L2(sol_rdmacm_dbg_str,
			    "ibt_query_hca_ports_byguid failed %d", status);
			continue;
		}

		for (p = 0, tmp = port_info; p < num_ports; p++, tmp++) {
			uint_t		s, num_sgids;
			uint16_t	pk;
			uint_t		num_pkeys;

			if (tmp->p_linkstate != IBT_PORT_ACTIVE)
				continue;

			num_sgids = tmp->p_sgid_tbl_sz / sizeof (ib_gid_t);
			num_pkeys = tmp->p_pkey_tbl_sz / sizeof (ib_pkey_t);

			for (s = 0; s < num_sgids; s++) {
				/* Skip holes in sgid table */
				if (tmp->p_sgid_tbl[s].gid_guid == 0x0LL)
					continue;
				for (pk = 0; pk < num_pkeys; pk++) {
					/* Skip holes in pkey table */
					if (tmp->p_pkey_tbl[pk] == 0)
						continue;
					if (with_ipaddr_only == B_TRUE) {
						bcopy(&tmp->p_sgid_tbl[s],
						    &attr.sip_gid,
						    sizeof (ib_gid_t));
						attr.sip_pkey =
						    tmp->p_pkey_tbl[pk];
						attr.sip_family = AF_INET;
						attr.sip_zoneid = 0;

						status = ibt_get_src_ip(&attr,
						    &src_info, &entries);
						if (status != IBT_SUCCESS)
							continue;
					}

					/* allocate devinfo & fill in info */
					devp = kmem_zalloc(
					    sizeof (ibcma_dev_t), KM_SLEEP);
					devp->dev_node_guid = hca_guidp[i];
					devp->dev_port_num = p + 1;
					devp->dev_pkey_ix = pk;
					devp->dev_pkey = tmp->p_pkey_tbl[pk];
					devp->dev_sgid = tmp->p_sgid_tbl[s];
					if (with_ipaddr_only == B_TRUE) {
						bcopy(&src_info[0].ip_addr,
						    &devp->dev_ipaddr,
						    sizeof (ibt_ip_addr_t));
						ibt_free_srcip_info(src_info,
						    entries);
					}

					SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
					    "get_devlist: add2devlist "
					    "node_guid %llx", hca_guidp[i]);
					(void) add_genlist(ret_devlist,
					    (uintptr_t)devp, NULL);
				}
			}
		}
		ibt_free_portinfo(port_info, port_size);
	}
}


#ifdef	QP_DEBUG
static void
dump_qp_info(ibt_qp_hdl_t qphdl)
{
	ibt_qp_query_attr_t	qp_query;
	ibt_qp_info_t		*qp_info;
	ibt_status_t		status;
	ibt_qp_rc_attr_t	*rcp;

	bzero(&qp_query, sizeof (qp_query));
	status = ibt_query_qp(qphdl, &qp_query);
	if (status != IBT_SUCCESS) {
		cmn_err(CE_WARN, "query_qp failed!!");
		return;
	}
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "QP HDL : %p, qp_sq_cq %p, qp_rq_cq %p, "
	    "qp_rdd_hdl %p, qp_qpn %x, qp_sq_sgl %x, qp_rq_sgl %x, "
	    "qp_srq %p, quer_attr.qp_flags %x",
	    qphdl, qp_query.qp_sq_cq, qp_query.qp_rq_cq,
	    qp_query.qp_rdd_hdl, qp_query.qp_qpn,
	    qp_query.qp_sq_sgl, qp_query.qp_rq_sgl,
	    qp_query.qp_srq, qp_query.qp_flags);
	qp_info = &(qp_query.qp_info);
	rcp = &((qp_info->qp_transport).rc);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "qp_sq_sz %x, qp_rq_sz %x, qp_state %x, "
	    "qp_current_state %x, qp_info.qp_flags %x, qp_trans %x",
	    qp_info->qp_sq_sz, qp_info->qp_rq_sz, qp_info->qp_state,
	    qp_info->qp_current_state, qp_info->qp_flags,
	    qp_info->qp_trans);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "rc_sq_psn %x, rc_rq_psn %x, rc_dst_qpn %x, "
	    "rc_mig_state %x, rc_rnr_retry_cnt %x, rc_retry_cnt %x, "
	    "rc_rdma_ra_out %x, rc_rdma_ra_in %x, rc_min_rnr_nak %x, "
	    "rc_path_mtu %x", rcp->rc_sq_psn, rcp->rc_rq_psn,
	    rcp->rc_dst_qpn, rcp->rc_mig_state, rcp->rc_rnr_retry_cnt,
	    rcp->rc_retry_cnt, rcp->rc_rdma_ra_out, rcp->rc_rdma_ra_in,
	    rcp->rc_min_rnr_nak, rcp->rc_path_mtu);
	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
	    "av_dgid %llx: %llx, av_sgid: %llx, "
	    "srate %x, srvl %x, flow %x, tclass %x, hop %x, "
	    "av_port_num %x, av_send_grh %x, av_dlid %x, "
	    "av_src_path %x, av_sgid_ix %x, pkey_index %x, "
	    "port_num %x",
	    (rcp->rc_path).cep_adds_vect.av_sgid.gid_prefix,
	    (rcp->rc_path).cep_adds_vect.av_sgid.gid_guid,
	    (rcp->rc_path).cep_adds_vect.av_dgid.gid_prefix,
	    (rcp->rc_path).cep_adds_vect.av_dgid.gid_guid,
	    (rcp->rc_path).cep_adds_vect.av_srate,
	    (rcp->rc_path).cep_adds_vect.av_srvl,
	    (rcp->rc_path).cep_adds_vect.av_flow,
	    (rcp->rc_path).cep_adds_vect.av_tclass,
	    (rcp->rc_path).cep_adds_vect.av_hop,
	    (rcp->rc_path).cep_adds_vect.av_port_num,
	    (rcp->rc_path).cep_adds_vect.av_opaque1,
	    (rcp->rc_path).cep_adds_vect.av_opaque2,
	    (rcp->rc_path).cep_adds_vect.av_opaque3,
	    (rcp->rc_path).cep_adds_vect.av_opaque4,
	    (rcp->rc_path).cep_pkey_ix,
	    (rcp->rc_path).cep_hca_port_num);
}
#endif

static void
dump_priv_data(void *priv_data, ibt_priv_data_len_t arr_len,
    ibt_priv_data_len_t priv_len, char *caller)
{
	uint8_t	i;
	uchar_t *c = (uchar_t *)priv_data;

	SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str, "priv_data to %s: %p, len %d",
	    caller, priv_data, priv_len);
	if (!priv_len || !priv_data)
		return;

	/* Display in rows of 16 uchar_t */
	for (i = 0; i < arr_len; i += 16)
		SOL_OFS_DPRINTF_L5(sol_rdmacm_dbg_str,
		    "%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
		    c[i], c[i + 1], c[i + 2], c[i + 3], c[i + 4], c[i + 5],
		    c[i + 6], c[i + 7], c[i + 8], c[i + 9], c[i + 10],
		    c[i + 11], c[i + 12], c[i + 13], c[i + 14], c[i + 15]);

}