xref: /illumos-gate/usr/src/uts/common/io/ib/mgt/ibmf/ibmf_impl.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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This file implements the client interfaces of the IBMF.
 */

#include <sys/ib/mgt/ibmf/ibmf_impl.h>
#include <sys/ib/mgt/ib_mad.h>

extern ibmf_state_t *ibmf_statep;

/* global settable */
int	ibmf_send_wqes_per_port = IBMF_MAX_SQ_WRE;
int	ibmf_recv_wqes_per_port = IBMF_MAX_RQ_WRE;
int	ibmf_send_wqes_posted_per_qp = IBMF_MAX_POSTED_SQ_PER_QP;
int	ibmf_recv_wqes_posted_per_qp = IBMF_MAX_POSTED_RQ_PER_QP;

int	ibmf_taskq_max_tasks = 1024;

int	ibmf_trace_level = DPRINT_L0;

#define	IBMF_MAD_CL_HDR_OFF_1	0
#define	IBMF_MAD_CL_HDR_OFF_2	12
#define	IBMF_MAD_CL_HDR_SZ_1	40
#define	IBMF_MAD_CL_HDR_SZ_2	20
#define	IBMF_MAD_CL_HDR_SZ_3	0
#define	IBMF_MAD_CL_HDR_SZ_4	4

#define	IBMF_VALID_CLIENT_TYPE(client_type)		\
	((client_type) == SUBN_AGENT ||			\
	(client_type) == SUBN_MANAGER ||		\
	(client_type) == SUBN_ADM_AGENT ||		\
	(client_type) == SUBN_ADM_MANAGER ||		\
	(client_type) == PERF_AGENT ||			\
	(client_type) == PERF_MANAGER ||		\
	(client_type) == BM_AGENT ||			\
	(client_type) == BM_MANAGER ||			\
	(client_type) == DEV_MGT_AGENT ||		\
	(client_type) == DEV_MGT_MANAGER ||		\
	(client_type) == COMM_MGT_MANAGER_AGENT ||	\
	(client_type) == SNMP_MANAGER_AGENT ||		\
	(client_type) == VENDOR_09_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0A_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0B_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0C_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0D_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0E_MANAGER_AGENT ||	\
	(client_type) == VENDOR_0F_MANAGER_AGENT ||	\
	(client_type) == VENDOR_30_MANAGER_AGENT ||	\
	(client_type) == VENDOR_31_MANAGER_AGENT ||	\
	(client_type) == VENDOR_32_MANAGER_AGENT ||	\
	(client_type) == VENDOR_33_MANAGER_AGENT ||	\
	(client_type) == VENDOR_34_MANAGER_AGENT ||	\
	(client_type) == VENDOR_35_MANAGER_AGENT ||	\
	(client_type) == VENDOR_36_MANAGER_AGENT ||	\
	(client_type) == VENDOR_37_MANAGER_AGENT ||	\
	(client_type) == VENDOR_38_MANAGER_AGENT ||	\
	(client_type) == VENDOR_39_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3A_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3B_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3C_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3D_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3E_MANAGER_AGENT ||	\
	(client_type) == VENDOR_3F_MANAGER_AGENT ||	\
	(client_type) == VENDOR_40_MANAGER_AGENT ||	\
	(client_type) == VENDOR_41_MANAGER_AGENT ||	\
	(client_type) == VENDOR_42_MANAGER_AGENT ||	\
	(client_type) == VENDOR_43_MANAGER_AGENT ||	\
	(client_type) == VENDOR_44_MANAGER_AGENT ||	\
	(client_type) == VENDOR_45_MANAGER_AGENT ||	\
	(client_type) == VENDOR_46_MANAGER_AGENT ||	\
	(client_type) == VENDOR_47_MANAGER_AGENT ||	\
	(client_type) == VENDOR_48_MANAGER_AGENT ||	\
	(client_type) == VENDOR_49_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4A_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4B_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4C_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4D_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4E_MANAGER_AGENT ||	\
	(client_type) == VENDOR_4F_MANAGER_AGENT ||	\
	(client_type) == APPLICATION_10_MANAGER_AGENT || \
	(client_type) == APPLICATION_11_MANAGER_AGENT || \
	(client_type) == APPLICATION_12_MANAGER_AGENT || \
	(client_type) == APPLICATION_13_MANAGER_AGENT || \
	(client_type) == APPLICATION_14_MANAGER_AGENT || \
	(client_type) == APPLICATION_15_MANAGER_AGENT || \
	(client_type) == APPLICATION_16_MANAGER_AGENT || \
	(client_type) == APPLICATION_17_MANAGER_AGENT || \
	(client_type) == APPLICATION_18_MANAGER_AGENT || \
	(client_type) == APPLICATION_19_MANAGER_AGENT || \
	(client_type) == APPLICATION_1A_MANAGER_AGENT || \
	(client_type) == APPLICATION_1B_MANAGER_AGENT || \
	(client_type) == APPLICATION_1C_MANAGER_AGENT || \
	(client_type) == APPLICATION_1D_MANAGER_AGENT || \
	(client_type) == APPLICATION_1E_MANAGER_AGENT || \
	(client_type) == APPLICATION_1F_MANAGER_AGENT || \
	(client_type) == APPLICATION_20_MANAGER_AGENT || \
	(client_type) == APPLICATION_21_MANAGER_AGENT || \
	(client_type) == APPLICATION_22_MANAGER_AGENT || \
	(client_type) == APPLICATION_23_MANAGER_AGENT || \
	(client_type) == APPLICATION_24_MANAGER_AGENT || \
	(client_type) == APPLICATION_25_MANAGER_AGENT || \
	(client_type) == APPLICATION_26_MANAGER_AGENT || \
	(client_type) == APPLICATION_27_MANAGER_AGENT || \
	(client_type) == APPLICATION_28_MANAGER_AGENT || \
	(client_type) == APPLICATION_29_MANAGER_AGENT || \
	(client_type) == APPLICATION_2A_MANAGER_AGENT || \
	(client_type) == APPLICATION_2B_MANAGER_AGENT || \
	(client_type) == APPLICATION_2C_MANAGER_AGENT || \
	(client_type) == APPLICATION_2D_MANAGER_AGENT || \
	(client_type) == APPLICATION_2E_MANAGER_AGENT || \
	(client_type) == APPLICATION_2F_MANAGER_AGENT || \
	(client_type) == UNIVERSAL_CLASS)

static ibmf_ci_t *ibmf_i_lookup_ci(ib_guid_t ci_guid);
static int ibmf_i_init_ci(ibmf_register_info_t *client_infop,
    ibmf_ci_t *cip);
static void ibmf_i_uninit_ci(ibmf_ci_t *cip);
static void ibmf_i_init_ci_done(ibmf_ci_t *cip);
static void ibmf_i_uninit_ci_done(ibmf_ci_t *cip);
static int ibmf_i_init_qp(ibmf_ci_t *ibmf_cip, ibmf_qp_t *qpp);
static void ibmf_i_uninit_qp(ibmf_ci_t *ibmf_cip, ibmf_qp_t *qpp);
static int ibmf_i_init_cqs(ibmf_ci_t *cip);
static void ibmf_i_fini_cqs(ibmf_ci_t *cip);
static void ibmf_i_init_qplist(ibmf_ci_t *ibmf_cip);
static void ibmf_i_fini_qplist(ibmf_ci_t *ibmf_cip);
static int ibmf_i_lookup_client_by_info(ibmf_ci_t *ibmf_cip,
    ibmf_register_info_t *ir_client, ibmf_client_t **clientpp);

/*
 * ibmf_init():
 *	Initializes module state and registers with the IBT framework.
 * 	Returns 0 if initialization was successful, else returns non-zero.
 */
int
ibmf_init(void)
{
	ibt_status_t 	status;
	ibt_clnt_hdl_t 	ibmf_ibt_handle;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_init_start,
	    IBMF_TNF_TRACE, "", "ibmf_init() enter\n");

	/* setup the IBT module information */
	ibmf_statep->ibmf_ibt_modinfo.mi_ibt_version = IBTI_V_CURR;
	ibmf_statep->ibmf_ibt_modinfo.mi_clnt_class = IBT_IBMA;
	ibmf_statep->ibmf_ibt_modinfo.mi_async_handler
	    = ibmf_ibt_async_handler;
	ibmf_statep->ibmf_ibt_modinfo.mi_reserved = NULL;
	ibmf_statep->ibmf_ibt_modinfo.mi_clnt_name = "ibmf";

	/* setup a connection to IB transport layer (IBTF) */
	status = ibt_attach(&ibmf_statep->ibmf_ibt_modinfo, (void *)NULL,
	    (void *)NULL, (void *)&ibmf_ibt_handle);
	if (status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_init_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    "ibt attach failed", tnf_uint, status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_init_end,
		    IBMF_TNF_TRACE, "", "ibmf_init() exit\n");
		return (1);
	}

	/* initialize the IBMF state context */
	ibmf_statep->ibmf_ibt_handle = ibmf_ibt_handle;
	ibmf_statep->ibmf_ci_list = (ibmf_ci_t *)NULL;
	ibmf_statep->ibmf_ci_list_tail = (ibmf_ci_t *)NULL;
	mutex_init(&ibmf_statep->ibmf_mutex, NULL, MUTEX_DRIVER, NULL);
	ibmf_statep->ibmf_cq_handler = ibmf_i_mad_completions;

	ibmf_statep->ibmf_taskq = taskq_create("ibmf_taskq", IBMF_TASKQ_1THREAD,
	    MINCLSYSPRI, 1, ibmf_taskq_max_tasks, TASKQ_PREPOPULATE);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_init_end,
	    IBMF_TNF_TRACE, "", "ibmf_init() exit\n");

	return (0);
}

/*
 * ibmf_fini():
 *	Cleans up module state resources and unregisters from IBT framework.
 */
int
ibmf_fini(void)
{
	ibmf_ci_t	*cip;
	ibmf_ci_t	*tcip;
	ibt_status_t	status;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_fini_start,
	    IBMF_TNF_TRACE, "", "ibmf_fini() enter\n");

	ASSERT(MUTEX_NOT_HELD(&ibmf_statep->ibmf_mutex));

	mutex_enter(&ibmf_statep->ibmf_mutex);

	/* free all the Channel Interface (CI) context structures */
	cip = ibmf_statep->ibmf_ci_list;
	tcip = NULL;
	while (cip != (ibmf_ci_t *)NULL) {

		mutex_enter(&cip->ci_mutex);
		ASSERT((cip->ci_state == IBMF_CI_STATE_PRESENT && cip->ci_ref ==
		    0) || (cip->ci_state == IBMF_CI_STATE_GONE));
		ASSERT(cip->ci_init_state == IBMF_CI_INIT_HCA_LINKED);
		ASSERT(cip->ci_qp_list == NULL && cip->ci_qp_list_tail == NULL);
		if (tcip != (ibmf_ci_t *)NULL)
			tcip->ci_next = cip->ci_next;
		if (ibmf_statep->ibmf_ci_list_tail == cip)
			ibmf_statep->ibmf_ci_list_tail = NULL;
		if (ibmf_statep->ibmf_ci_list == cip)
			ibmf_statep->ibmf_ci_list = cip->ci_next;
		tcip = cip->ci_next;
		mutex_exit(&cip->ci_mutex);
		/* free up the ci structure */
		if (cip->ci_port_kstatp != NULL) {
			kstat_delete(cip->ci_port_kstatp);
		}
		mutex_destroy(&cip->ci_mutex);
		mutex_destroy(&cip->ci_clients_mutex);
		mutex_destroy(&cip->ci_wqe_mutex);
		cv_destroy(&cip->ci_state_cv);
		cv_destroy(&cip->ci_wqes_cv);
		kmem_free((void *) cip, sizeof (ibmf_ci_t));
		cip = tcip;
	}

	ASSERT(ibmf_statep->ibmf_ci_list == NULL);
	ASSERT(ibmf_statep->ibmf_ci_list_tail == NULL);

	taskq_destroy(ibmf_statep->ibmf_taskq);

	mutex_exit(&ibmf_statep->ibmf_mutex);

	/* detach from IBTF */
	status = ibt_detach(ibmf_statep->ibmf_ibt_handle);
	if (status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_fini_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    "ibt detach error", tnf_uint, status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_fini_end,
		    IBMF_TNF_TRACE, "", "ibmf_fini() exit\n");
		return (1);
	}

	mutex_destroy(&ibmf_statep->ibmf_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_fini_end,
	    IBMF_TNF_TRACE, "", "ibmf_fini() exit\n");

	return (0);
}

/*
 * ibmf_i_validate_class_mask():
 *	Checks client type value in client information structure.
 */
int
ibmf_i_validate_class_mask(ibmf_register_info_t	*client_infop)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_validate_class_mask_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_validate_class_mask() enter, client_infop = %p\n",
	    tnf_opaque, client_infop, client_infop);

	if (IBMF_VALID_CLIENT_TYPE(client_infop->ir_client_class) == B_FALSE) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_validate_class_mask_err, IBMF_TNF_ERROR, "",
		    "%s, class = %x\n", tnf_string, msg,
		    "invalid class", tnf_uint, class,
		    client_infop->ir_client_class);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_validate_class_mask_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_validate_class_mask() exit\n");
		return (IBMF_BAD_CLASS);
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_validate_class_mask_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_validate_class_mask() exit\n");
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_validate_ci_guid_and_port():
 *	Checks validity of port number and HCA GUID at client
 *	registration time.
 */
int
ibmf_i_validate_ci_guid_and_port(ib_guid_t hca_guid, uint8_t port_num)
{
	ibt_status_t	status;
	ibt_hca_attr_t	hca_attrs;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_validate_ci_guid_and_port_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_validate_ci_guid_and_port() enter, hca_guid = %x, "
	    "port_num = %d\n", tnf_opaque, hca_guid, hca_guid,
	    tnf_uint, port_num, port_num);

	/* check for incorrect port number specification */
	if (port_num == 0) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, 1,
		    ibmf_i_validate_ci_guid_and_port_err, IBMF_TNF_ERROR, "",
		    "%s\n", tnf_string, msg, "port num is 0");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_validate_ci_guid_and_port_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_validate_ci_guid_and_port() exit\n");
		return (IBMF_BAD_PORT);
	}

	/* call IB transport layer for HCA attributes */
	status = ibt_query_hca_byguid(hca_guid, &hca_attrs);
	if (status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_validate_ci_guid_and_port_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    "query_hca_guid failed", tnf_uint, status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_validate_ci_guid_and_port_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_validate_ci_guid_and_port() exit\n");
		return (IBMF_BAD_NODE);
	}

	/* check if the specified port number is within the HCAs range */
	if (port_num > hca_attrs.hca_nports) {
		IBMF_TRACE_3(IBMF_TNF_NODEBUG, 1,
		    ibmf_i_validate_ci_guid_and_port_err, IBMF_TNF_ERROR, "",
		    "%s, num = %d, hca_ports = %d\n",
		    tnf_string, msg, "port num > valid ports",
		    tnf_uint, num, port_num, tnf_uint, hca_nports,
		    hca_attrs.hca_nports);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_validate_ci_guid_and_port_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_validate_ci_guid_and_port() exit\n");
		return (IBMF_BAD_PORT);
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_validate_ci_guid_and_port_end, IBMF_TNF_TRACE, "",
	    "ibmf_i_validate_ci_guid_and_port() exit\n");
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_lookup_ci():
 * 	Lookup the ci and return if found. If the CI is not found, returns
 * 	NULL.
 */
static ibmf_ci_t *
ibmf_i_lookup_ci(ib_guid_t ci_guid)
{
	ibmf_ci_t	*cip = NULL;

	ASSERT(MUTEX_NOT_HELD(&ibmf_statep->ibmf_mutex));

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_lookup_ci_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_lookup_ci(): enter, guid = 0x%x\n",
	    tnf_uint64, guid, ci_guid);

	/* walk the CI list looking for one that matches the provided GUID */
	mutex_enter(&ibmf_statep->ibmf_mutex);
	cip = ibmf_statep->ibmf_ci_list;
	while (cip != (ibmf_ci_t *)NULL) {
		if (ci_guid == cip->ci_node_guid) {
			/* found it in our list */
			break;
		}
		cip = cip->ci_next;
	}
	mutex_exit(&ibmf_statep->ibmf_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_lookup_ci_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_lookup_ci() exit\n");

	return (cip);
}

/*
 * ibmf_i_get_ci():
 *	Get the CI structure based on the HCA GUID from a list if it exists.
 *	If the CI structure does not exist, and the HCA GUID is valid,
 *	create a new CI structure and add it to the list.
 */
int
ibmf_i_get_ci(ibmf_register_info_t *client_infop, ibmf_ci_t **cipp)
{
	ibmf_ci_t 		*cip;
	ibt_status_t		status;
	boolean_t		invalid = B_FALSE;
	ibt_hca_attr_t		hca_attrs;
	ibmf_port_kstat_t	*ksp;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_ci_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_get_ci() enter, clinfop = %p\n",
	    tnf_opaque, client_infop, client_infop);

	/* look for a CI context with a matching GUID */
	cip = ibmf_i_lookup_ci(client_infop->ir_ci_guid);

	if (cip == NULL) {

		/*
		 * attempt to create the ci. First, verify the ci exists.
		 * If it exists, allocate ci memory and insert in the ci list.
		 * It is possible that some other thread raced with us
		 * and inserted created ci while we are blocked in
		 * allocating memory. Check for that case and if that is indeed
		 * the case, free up what we allocated and try to get a
		 * reference count on the ci that the other thread added.
		 */
		status = ibt_query_hca_byguid(client_infop->ir_ci_guid,
		    &hca_attrs);
		if (status == IBT_SUCCESS) {

			ibmf_ci_t *tcip;
			char buf[128];

			/* allocate memory for the CI structure */
			cip = (ibmf_ci_t *)kmem_zalloc(sizeof (ibmf_ci_t),
			    KM_SLEEP);

			_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cip))

			mutex_init(&cip->ci_mutex, NULL, MUTEX_DRIVER, NULL);
			mutex_init(&cip->ci_clients_mutex, NULL, MUTEX_DRIVER,
			    NULL);
			mutex_init(&cip->ci_wqe_mutex, NULL, MUTEX_DRIVER,
			    NULL);
			cv_init(&cip->ci_state_cv, NULL, CV_DRIVER, NULL);
			cv_init(&cip->ci_wqes_cv, NULL, CV_DRIVER, NULL);

			(void) sprintf(buf, "r%08X",
			    (uint32_t)client_infop->ir_ci_guid);
			mutex_enter(&cip->ci_mutex);

			cip->ci_state = IBMF_CI_STATE_PRESENT;
			cip->ci_node_guid = client_infop->ir_ci_guid;

			/* set up per CI kstats */
			(void) sprintf(buf, "ibmf_%016" PRIx64 "_%d_stat",
			    client_infop->ir_ci_guid,
			    client_infop->ir_port_num);
			if ((cip->ci_port_kstatp = kstat_create("ibmf", 0, buf,
			    "misc", KSTAT_TYPE_NAMED,
			    sizeof (ibmf_port_kstat_t) / sizeof (kstat_named_t),
			    KSTAT_FLAG_WRITABLE)) == NULL) {
				mutex_exit(&cip->ci_mutex);
				mutex_destroy(&cip->ci_mutex);
				mutex_destroy(&cip->ci_clients_mutex);
				mutex_destroy(&cip->ci_wqe_mutex);
				cv_destroy(&cip->ci_state_cv);
				cv_destroy(&cip->ci_wqes_cv);
				kmem_free((void *)cip, sizeof (ibmf_ci_t));
				IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
				    ibmf_i_get_ci_err, IBMF_TNF_ERROR, "",
				    "%s\n", tnf_string, msg,
				    "kstat create failed");
				IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
				    ibmf_i_get_ci_end, IBMF_TNF_TRACE, "",
				    "ibmf_i_get_ci() exit\n");
				return (IBMF_NO_RESOURCES);
			}
			ksp = (ibmf_port_kstat_t *)cip->ci_port_kstatp->ks_data;
			kstat_named_init(&ksp->clients_registered,
			    "clients_registered", KSTAT_DATA_UINT32);
			kstat_named_init(&ksp->client_regs_failed,
			    "client_registrations_failed", KSTAT_DATA_UINT32);
			kstat_named_init(&ksp->send_wqes_alloced,
			    "send_wqes_allocated", KSTAT_DATA_UINT32);
			kstat_named_init(&ksp->recv_wqes_alloced,
			    "receive_wqes_allocated", KSTAT_DATA_UINT32);
			kstat_named_init(&ksp->swqe_allocs_failed,
			    "send_wqe_allocs_failed", KSTAT_DATA_UINT32);
			kstat_named_init(&ksp->rwqe_allocs_failed,
			    "recv_wqe_allocs_failed", KSTAT_DATA_UINT32);
			kstat_install(cip->ci_port_kstatp);

			mutex_exit(&cip->ci_mutex);

			mutex_enter(&ibmf_statep->ibmf_mutex);

			tcip = ibmf_statep->ibmf_ci_list;
			while (tcip != (ibmf_ci_t *)NULL) {
				if (client_infop->ir_ci_guid ==
				    tcip->ci_node_guid) {
					/* found it in our list */
					break;
				}
				tcip = tcip->ci_next;
			}

			/* if the ci isn't on the list, add it */
			if (tcip == NULL) {
				cip->ci_next = NULL;

				_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cip))

				if (ibmf_statep->ibmf_ci_list_tail != NULL)
					ibmf_statep->ibmf_ci_list_tail->
					    ci_next = cip;
				if (ibmf_statep->ibmf_ci_list == NULL)
					ibmf_statep->ibmf_ci_list = cip;
				ibmf_statep->ibmf_ci_list_tail = cip;

				mutex_enter(&cip->ci_mutex);
				cip->ci_init_state |= IBMF_CI_INIT_HCA_LINKED;
				mutex_exit(&cip->ci_mutex);

			} else {
				/* free cip and set it to the one on the list */
				kstat_delete(cip->ci_port_kstatp);
				mutex_destroy(&cip->ci_mutex);
				mutex_destroy(&cip->ci_clients_mutex);
				mutex_destroy(&cip->ci_wqe_mutex);
				cv_destroy(&cip->ci_state_cv);
				cv_destroy(&cip->ci_wqes_cv);
				kmem_free((void *)cip, sizeof (ibmf_ci_t));

				_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cip))

				cip = tcip;
			}
			mutex_exit(&ibmf_statep->ibmf_mutex);
		} else {
			/* we didn't find it and the CI doesn't exist */
			IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L1,
			    ibmf_i_get_ci_err, IBMF_TNF_ERROR, "", "%s\n",
			    tnf_string, msg, "GUID doesn't exist");
			IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_get_ci_end, IBMF_TNF_TRACE, "",
			    "ibmf_i_get_ci() exit\n");
			return (IBMF_TRANSPORT_FAILURE);
		}
	}

	ASSERT(cip != NULL);

	/*
	 * We now have a CI context structure, either found it on the list,
	 * or created it.
	 * We now proceed to intialize the CI context.
	 */
	for (;;) {
		mutex_enter(&cip->ci_mutex);

		/* CI is INITED & no state change in progress; we are all set */
		if (cip->ci_state == IBMF_CI_STATE_INITED && (cip->
		    ci_state_flags & (IBMF_CI_STATE_INVALIDATING |
		    IBMF_CI_STATE_UNINITING)) == 0) {

			cip->ci_ref++;
			mutex_exit(&cip->ci_mutex);

			break;
		}

		/* CI is PRESENT; transition it to INITED */
		if (cip->ci_state == IBMF_CI_STATE_PRESENT && (cip->
		    ci_state_flags & (IBMF_CI_STATE_INVALIDATING |
		    IBMF_CI_STATE_INITING)) == 0) {

			/* mark state as initing and init the ci */
			cip->ci_state_flags |= IBMF_CI_STATE_INITING;
			mutex_exit(&cip->ci_mutex);

			_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*cip))

			if (ibmf_i_init_ci(client_infop, cip) != IBMF_SUCCESS) {
				invalid = B_TRUE;
				break;
			}

			_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*cip))

			continue;
		}

		/*
		 * If CI is GONE and no validation is in progress, we should
		 * return failure. Also, if CI is INITED but in the process of
		 * being made GONE (ie., a hot remove in progress), return
		 * failure.
		 */
		if ((cip->ci_state == IBMF_CI_STATE_GONE && (cip->
		    ci_state_flags & IBMF_CI_STATE_VALIDATING) == 0) ||
		    (cip->ci_state == IBMF_CI_STATE_INITED && (cip->
		    ci_state_flags & IBMF_CI_STATE_INVALIDATING) != 0)) {

			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_get_ci_err, IBMF_TNF_ERROR, "",
			    "ci_state = %x, ci_state_flags = %x\n",
			    tnf_opaque, cip->ci_state, cip->ci_state,
			    tnf_opaque, cip->ci_state_flags,
			    cip->ci_state_flags);

			invalid = B_TRUE;
			mutex_exit(&cip->ci_mutex);

			break;
		}

		/* a state change in progress; block waiting for state change */
		if (cip->ci_state_flags & IBMF_CI_STATE_VALIDATING)
			cip->ci_state_flags |= IBMF_CI_STATE_VALIDATE_WAIT;
		else if (cip->ci_state_flags & IBMF_CI_STATE_INITING)
			cip->ci_state_flags |= IBMF_CI_STATE_INIT_WAIT;
		else if (cip->ci_state_flags & IBMF_CI_STATE_UNINITING)
			cip->ci_state_flags |= IBMF_CI_STATE_UNINIT_WAIT;

		cv_wait(&cip->ci_state_cv, &cip->ci_mutex);

		mutex_exit(&cip->ci_mutex);
	}

	if (invalid == B_TRUE) {
		IBMF_TRACE_0(IBMF_TNF_NODEBUG, DPRINT_L2, ibmf_i_get_ci_err,
		    IBMF_TNF_ERROR, "", "ibmf_i_get_ci() error\n");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_ci_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_ci() exit\n");
		return (IBMF_FAILURE);
	}

	if (cip != NULL) {
		*cipp = cip;
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_ci_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_ci() exit\n");
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_ci_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_ci() exit\n");
		return (IBMF_FAILURE);
	}
}

/*
 * ibmf_i_release_ci():
 *	Drop the reference count for the CI.
 */
void
ibmf_i_release_ci(ibmf_ci_t *cip)
{
	uint_t ref;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_release_ci_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_release_ci() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	ASSERT(MUTEX_NOT_HELD(&cip->ci_mutex));

	mutex_enter(&cip->ci_mutex);
	ref = cip->ci_ref--;
	if (ref == 1) {
		ASSERT(cip->ci_state == IBMF_CI_STATE_INITED);
		cip->ci_state_flags |= IBMF_CI_STATE_UNINITING;
	}
	mutex_exit(&cip->ci_mutex);

	if (ref == 1) {
		ibmf_i_uninit_ci(cip);
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_release_ci_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_release_ci() exit\n");
}

/*
 * ibmf_i_init_ci():
 *	Initialize the CI structure by setting up the HCA, allocating
 *	protection domains, completion queues, a pool of WQEs.
 */
/* ARGSUSED */
static int
ibmf_i_init_ci(ibmf_register_info_t *client_infop, ibmf_ci_t *cip)
{
	ibt_pd_hdl_t		pd;
	ibt_status_t		status;
	ib_guid_t		ci_guid;
	ibt_hca_attr_t		hca_attrs;
	ibt_hca_hdl_t		hca_handle;
	ibt_pd_flags_t		pd_flags = IBT_PD_NO_FLAGS;
	boolean_t		error = B_FALSE;
	int			ibmfstatus = IBMF_SUCCESS;
	char			errmsg[128];

	_NOTE(ASSUMING_PROTECTED(*cip))

	ASSERT(MUTEX_NOT_HELD(&ibmf_statep->ibmf_mutex));
	ASSERT(MUTEX_NOT_HELD(&cip->ci_mutex));

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_ci_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_ci() enter, cip = %p\n",
	    tnf_opaque, ibmf_ci, cip);

	mutex_enter(&cip->ci_mutex);
	ci_guid = cip->ci_node_guid;
	ASSERT(cip->ci_state == IBMF_CI_STATE_PRESENT);
	ASSERT((cip->ci_state_flags & IBMF_CI_STATE_INITING) != 0);
	mutex_exit(&cip->ci_mutex);

	/* set up a connection to the HCA specified by the GUID */
	status = ibt_open_hca(ibmf_statep->ibmf_ibt_handle, ci_guid,
	    &hca_handle);
	ASSERT(status != IBT_HCA_IN_USE);
	if (status != IBT_SUCCESS) {
		ibmf_i_init_ci_done(cip);
		(void) sprintf(errmsg, "ibt open hca failed, status = 0x%x",
		    status);
		error = B_TRUE;
		ibmfstatus = IBMF_TRANSPORT_FAILURE;
		goto bail;
	}

	/* get the HCA attributes */
	status = ibt_query_hca(hca_handle, &hca_attrs);
	if (status != IBT_SUCCESS) {
		(void) ibt_close_hca(hca_handle);
		ibmf_i_init_ci_done(cip);
		(void) sprintf(errmsg, "ibt query hca failed, status = 0x%x",
		    status);
		error = B_TRUE;
		ibmfstatus = IBMF_TRANSPORT_FAILURE;
		goto bail;
	}

	/* allocate a Protection Domain */
	status = ibt_alloc_pd(hca_handle, pd_flags, &pd);
	if (status != IBT_SUCCESS) {
		(void) ibt_close_hca(hca_handle);
		ibmf_i_init_ci_done(cip);
		(void) sprintf(errmsg, "alloc PD failed, status = 0x%x",
		    status);
		error = B_TRUE;
		ibmfstatus = IBMF_TRANSPORT_FAILURE;
		goto bail;
	}

	/* init the ci */
	mutex_enter(&cip->ci_mutex);
	cip->ci_nports = hca_attrs.hca_nports;
	cip->ci_vendor_id = hca_attrs.hca_vendor_id;
	cip->ci_device_id = hca_attrs.hca_device_id;
	cip->ci_ci_handle = hca_handle;
	cip->ci_pd = pd;
	cip->ci_init_state |= IBMF_CI_INIT_HCA_INITED;
	mutex_exit(&cip->ci_mutex);

	/* initialize cqs */
	if (ibmf_i_init_cqs(cip) != IBMF_SUCCESS) {
		(void) ibt_free_pd(cip->ci_ci_handle, cip->ci_pd);
		mutex_enter(&cip->ci_mutex);
		cip->ci_init_state &= ~IBMF_CI_INIT_HCA_INITED;
		mutex_exit(&cip->ci_mutex);
		(void) ibt_close_hca(cip->ci_ci_handle);
		ibmf_i_init_ci_done(cip);
		(void) sprintf(errmsg, "init CQs failed");
		error = B_TRUE;
		ibmfstatus = IBMF_FAILURE;
		goto bail;
	}

	/* initialize wqes */
	if (ibmf_i_init_wqes(cip) != IBMF_SUCCESS) {
		ibmf_i_fini_cqs(cip);
		(void) ibt_free_pd(cip->ci_ci_handle, cip->ci_pd);
		mutex_enter(&cip->ci_mutex);
		cip->ci_init_state &= ~IBMF_CI_INIT_HCA_INITED;
		mutex_exit(&cip->ci_mutex);
		(void) ibt_close_hca(cip->ci_ci_handle);
		ibmf_i_init_ci_done(cip);
		(void) sprintf(errmsg, "init WQEs failed");
		error = B_TRUE;
		ibmfstatus = IBMF_FAILURE;
		goto bail;
	}

	/* initialize the UD destination structure pool */
	ibmf_i_init_ud_dest(cip);

	/* initialize the QP list */
	ibmf_i_init_qplist(cip);

	/* initialize condition variable, state, and enable CQ notification */
	cip->ci_init_state |= IBMF_CI_INIT_MUTEX_CV_INITED;
	(void) ibt_enable_cq_notify(cip->ci_cq_handle, IBT_NEXT_COMPLETION);
	(void) ibt_enable_cq_notify(cip->ci_alt_cq_handle, IBT_NEXT_COMPLETION);

	/* set state to INITED */
	mutex_enter(&cip->ci_mutex);
	cip->ci_state = IBMF_CI_STATE_INITED;
	mutex_exit(&cip->ci_mutex);

	/* wake up waiters blocked on an initialization done event */
	ibmf_i_init_ci_done(cip);

bail:
	if (error) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_ci_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    errmsg, tnf_uint, ibmfstatus, ibmfstatus);
	}

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_ci_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_ci() exit, cip = %p\n",
	    tnf_opaque, ibmf_ci, cip);

	return (ibmfstatus);
}

/*
 * ibmf_i_uninit_ci():
 *	Free up the resources allocated when initializing the CI structure.
 */
static void
ibmf_i_uninit_ci(ibmf_ci_t *cip)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_ci_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_ci() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	ASSERT(MUTEX_HELD(&cip->ci_mutex) == 0);

	/* clean up the QP list */
	ibmf_i_fini_qplist(cip);

	/* empty completions directly */
	ibmf_i_mad_completions(cip->ci_cq_handle, (void*)cip);
	ibmf_i_mad_completions(cip->ci_alt_cq_handle, (void*)cip);

	mutex_enter(&cip->ci_mutex);
	if (cip->ci_init_state & IBMF_CI_INIT_MUTEX_CV_INITED) {
		cip->ci_init_state &= ~IBMF_CI_INIT_MUTEX_CV_INITED;
	}
	mutex_exit(&cip->ci_mutex);

	/* clean up the UD destination structure pool */
	ibmf_i_fini_ud_dest(cip);

	/* clean up any WQE caches */
	ibmf_i_fini_wqes(cip);

	/* free up the completion queues */
	ibmf_i_fini_cqs(cip);

	/* free up the protection domain */
	(void) ibt_free_pd(cip->ci_ci_handle, cip->ci_pd);

	/* close the HCA connection */
	(void) ibt_close_hca(cip->ci_ci_handle);

	/* set state down to PRESENT */
	mutex_enter(&cip->ci_mutex);
	cip->ci_init_state &= ~IBMF_CI_INIT_HCA_INITED;
	cip->ci_state = IBMF_CI_STATE_PRESENT;
	mutex_exit(&cip->ci_mutex);

	/* wake up waiters blocked on an un-initialization done event */
	ibmf_i_uninit_ci_done(cip);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_ci_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_ci() exit\n");
}

/*
 * ibmf_i_init_ci_done():
 *	Mark CI initialization as "done", and wake up any waiters.
 */
static void
ibmf_i_init_ci_done(ibmf_ci_t *cip)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_ci_done_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_ci_done() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	mutex_enter(&cip->ci_mutex);
	cip->ci_state_flags &= ~IBMF_CI_STATE_INITING;
	if (cip->ci_state_flags & IBMF_CI_STATE_INIT_WAIT) {
		cip->ci_state_flags &= ~IBMF_CI_STATE_INIT_WAIT;
		cv_broadcast(&cip->ci_state_cv);
	}
	mutex_exit(&cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_ci_done_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_ci_done() exit\n");
}

/*
 * ibmf_i_uninit_ci_done():
 *	Mark CI uninitialization as "done", and wake up any waiters.
 */
static void
ibmf_i_uninit_ci_done(ibmf_ci_t *cip)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_ci_done_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_ci_done() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	mutex_enter(&cip->ci_mutex);
	cip->ci_state_flags &= ~IBMF_CI_STATE_UNINITING;
	if (cip->ci_state_flags & IBMF_CI_STATE_UNINIT_WAIT) {
		cip->ci_state_flags &= ~IBMF_CI_STATE_UNINIT_WAIT;
		cv_broadcast(&cip->ci_state_cv);
	}
	mutex_exit(&cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_ci_done_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_ci_done() exit\n");
}

/*
 * ibmf_i_init_cqs():
 *	Allocate a completion queue and set the CQ handler.
 */
static int
ibmf_i_init_cqs(ibmf_ci_t *cip)
{
	ibt_status_t		status;
	ibt_cq_attr_t		cq_attrs;
	ibt_cq_hdl_t		cq_handle;
	uint32_t		num_entries;

	ASSERT(MUTEX_NOT_HELD(&cip->ci_mutex));

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_cqs_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_cqs() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	/*
	 * Allocate completion queue handle.
	 * The CQ size should be a 2^n - 1 value to avoid excess CQ allocation
	 * as done by some HCAs when the CQ size is specified as a 2^n
	 * quantity.
	 */
	cq_attrs.cq_size = (cip->ci_nports * (ibmf_send_wqes_posted_per_qp +
	    ibmf_recv_wqes_posted_per_qp)) - 1;

	cq_attrs.cq_sched = NULL;
	cq_attrs.cq_flags = 0;

	/* Get the CQ handle for the special QPs */
	status = ibt_alloc_cq(cip->ci_ci_handle, &cq_attrs,
	    &cq_handle, &num_entries);
	if (status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_cqs_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    "ibt_alloc_cq failed", tnf_uint, ibt_status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_cqs_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_init_cqs() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}
	ibt_set_cq_handler(cq_handle, ibmf_statep->ibmf_cq_handler, cip);
	cip->ci_cq_handle = cq_handle;

	/* Get the CQ handle for the alternate QPs */
	status = ibt_alloc_cq(cip->ci_ci_handle, &cq_attrs,
	    &cq_handle, &num_entries);
	if (status != IBT_SUCCESS) {
		(void) ibt_free_cq(cip->ci_cq_handle);
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_cqs_err,
		    IBMF_TNF_ERROR, "", "%s, status = %d\n", tnf_string, msg,
		    "ibt_alloc_cq failed", tnf_uint, ibt_status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_cqs_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_init_cqs() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}
	ibt_set_cq_handler(cq_handle, ibmf_statep->ibmf_cq_handler, cip);
	cip->ci_alt_cq_handle = cq_handle;

	/* set state to CQ INITED */
	mutex_enter(&cip->ci_mutex);
	cip->ci_init_state |= IBMF_CI_INIT_CQ_INITED;
	mutex_exit(&cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_cqs_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_cqs() exit\n");

	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_fini_cqs():
 *	Free up the completion queue
 */
static void
ibmf_i_fini_cqs(ibmf_ci_t *cip)
{
	ibt_status_t	status;
	uint_t		ci_init_state;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_fini_cqs_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_fini_cqs() enter, cip = %p\n",
	    tnf_opaque, cip, cip);

	mutex_enter(&cip->ci_mutex);
	ci_init_state = cip->ci_init_state;
	cip->ci_init_state &= ~IBMF_CI_INIT_CQ_INITED;
	mutex_exit(&cip->ci_mutex);

	if (ci_init_state & IBMF_CI_INIT_CQ_INITED) {
		status = ibt_free_cq(cip->ci_alt_cq_handle);
		if (status != IBT_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L3,
			    ibmf_i_fini_cqs_err, IBMF_TNF_ERROR, "",
			    "%s, status = %d\n", tnf_string, msg,
			    "ibt free cqs failed", tnf_uint, status, status);
		}

		status = ibt_free_cq(cip->ci_cq_handle);
		if (status != IBT_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L3,
			    ibmf_i_fini_cqs_err, IBMF_TNF_ERROR, "",
			    "%s, status = %d\n", tnf_string, msg,
			    "ibt free cqs failed", tnf_uint, status, status);
		}
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_fini_cqs_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_fini_cqs() exit");
}

/*
 * ibmf_i_init_qplist():
 *	Set the QP list inited state flag
 */
static void
ibmf_i_init_qplist(ibmf_ci_t *ibmf_cip)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qplist_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_qplist() enter, cip = %p\n",
	    tnf_opaque, cip, ibmf_cip);

	mutex_enter(&ibmf_cip->ci_mutex);
	ASSERT((ibmf_cip->ci_init_state & IBMF_CI_INIT_QP_LIST_INITED) == 0);
	ASSERT(ibmf_cip->ci_qp_list == NULL && ibmf_cip->ci_qp_list_tail ==
	    NULL);
	cv_init(&ibmf_cip->ci_qp_cv, NULL, CV_DRIVER, NULL);
	ibmf_cip->ci_init_state |= IBMF_CI_INIT_QP_LIST_INITED;
	mutex_exit(&ibmf_cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qplist_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_qplist() exit\n");
}

/*
 * ibmf_i_fini_qplist():
 *	Clean up the QP list
 */
static void
ibmf_i_fini_qplist(ibmf_ci_t *ibmf_cip)
{
	ibmf_qp_t *qpp;
	ibmf_alt_qp_t *altqpp;
	ibt_status_t status;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_fini_qplist_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_fini_qplist() enter, cip = %p\n",
	    tnf_opaque, cip, ibmf_cip);

	mutex_enter(&ibmf_cip->ci_mutex);

	if ((ibmf_cip->ci_init_state & IBMF_CI_INIT_QP_LIST_INITED) != 0) {

		/* walk through the qp list and free the memory */
		qpp = ibmf_cip->ci_qp_list;
		while (qpp != NULL) {
			/* Remove qpp from the list */
			ibmf_cip->ci_qp_list = qpp->iq_next;

			ASSERT(qpp->iq_qp_ref == 0);
			ASSERT(qpp->iq_flags == IBMF_QP_FLAGS_INVALID);
			mutex_exit(&ibmf_cip->ci_mutex);
			if (qpp->iq_qp_handle != NULL) {
				/* Flush the special QP */
				status = ibt_flush_qp(qpp->iq_qp_handle);
				if (status != IBT_SUCCESS) {
					IBMF_TRACE_2(IBMF_TNF_NODEBUG,
					    DPRINT_L1, ibmf_i_fini_qplist_err,
					    IBMF_TNF_ERROR, "",
					    "%s, status = %d\n", tnf_string,
					    msg, "ibt_flush_qp returned error",
					    tnf_int, status, status);
				}

				/* Grab the ci_mutex mutex before waiting */
				mutex_enter(&ibmf_cip->ci_mutex);

				/* Wait if WQEs for special QPs are alloced */
				while (ibmf_cip->ci_wqes_alloced != 0) {
					cv_wait(&ibmf_cip->ci_wqes_cv,
					    &ibmf_cip->ci_mutex);
				}

				mutex_exit(&ibmf_cip->ci_mutex);

				/* Free the special QP */
				status = ibt_free_qp(qpp->iq_qp_handle);
				if (status != IBT_SUCCESS) {
					IBMF_TRACE_2(IBMF_TNF_NODEBUG,
					    DPRINT_L1, ibmf_i_fini_qplist_err,
					    IBMF_TNF_ERROR, "",
					    "%s, status = %d\n", tnf_string,
					    msg, "ibt_free_qp returned error",
					    tnf_int, status, status);
				}
			}
			mutex_destroy(&qpp->iq_mutex);
			kmem_free((void *)qpp, sizeof (ibmf_qp_t));

			/* Grab the mutex again before accessing the QP list */
			mutex_enter(&ibmf_cip->ci_mutex);
			qpp = ibmf_cip->ci_qp_list;
		}

		cv_destroy(&ibmf_cip->ci_qp_cv);

		ibmf_cip->ci_qp_list = ibmf_cip->ci_qp_list_tail = NULL;
		ibmf_cip->ci_init_state &=  ~IBMF_CI_INIT_QP_LIST_INITED;

		altqpp = ibmf_cip->ci_alt_qp_list;
		while (altqpp != NULL) {
			/* Remove altqpp from the list */
			ibmf_cip->ci_alt_qp_list = altqpp->isq_next;
			mutex_exit(&ibmf_cip->ci_mutex);

			if (altqpp->isq_qp_handle != NULL) {
				/* Flush the special QP */
				status = ibt_flush_qp(altqpp->isq_qp_handle);
				if (status != IBT_SUCCESS) {
					IBMF_TRACE_2(IBMF_TNF_NODEBUG,
					    DPRINT_L1, ibmf_i_fini_qplist_err,
					    IBMF_TNF_ERROR, "",
					    "%s, status = %d\n", tnf_string,
					    msg, "ibt_flush_qp returned error",
					    tnf_int, status, status);
				}

				/* Free the special QP */
				status = ibt_free_qp(altqpp->isq_qp_handle);
				if (status != IBT_SUCCESS) {
					IBMF_TRACE_2(IBMF_TNF_NODEBUG,
					    DPRINT_L1, ibmf_i_fini_qplist_err,
					    IBMF_TNF_ERROR, "",
					    "%s, status = %d\n", tnf_string,
					    msg, "ibt_free_qp returned error",
					    tnf_int, status, status);
				}
			}
			mutex_destroy(&altqpp->isq_mutex);
			kmem_free((void *)altqpp, sizeof (ibmf_alt_qp_t));

			/* Grab the mutex again before accessing the QP list */
			mutex_enter(&ibmf_cip->ci_mutex);
			altqpp = ibmf_cip->ci_alt_qp_list;
		}
	}

	mutex_exit(&ibmf_cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_fini_qplist_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_fini_qplist() exit\n");
}

/*
 * ibmf_i_alloc_client():
 *	Allocate and initialize the client structure.
 */
int
ibmf_i_alloc_client(ibmf_register_info_t *client_infop, uint_t flags,
    ibmf_client_t **clientpp)
{
	ibmf_client_t		*ibmf_clientp;
	char			buf[128];
	ibmf_kstat_t		*ksp;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_alloc_client_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_alloc_client() enter, "
	    "client_infop = %p\n", tnf_opaque, client_infop, client_infop);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*ibmf_clientp))

	/* allocate memory for ibmf_client and initialize it */
	ibmf_clientp = kmem_zalloc(sizeof (ibmf_client_t), KM_SLEEP);
	mutex_init(&ibmf_clientp->ic_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&ibmf_clientp->ic_msg_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&ibmf_clientp->ic_kstat_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&ibmf_clientp->ic_recv_cb_teardown_cv, NULL, CV_DRIVER, NULL);

	(void) sprintf(buf, "s%08X_0x%08X",
	    (uint32_t)client_infop->ir_ci_guid, client_infop->ir_client_class);

	/* create a taskq to handle send completions based on reg flags */
	if ((flags & IBMF_REG_FLAG_NO_OFFLOAD) == 0) {
		if (flags & IBMF_REG_FLAG_SINGLE_OFFLOAD)
			ibmf_clientp->ic_send_taskq = taskq_create(buf,
			    IBMF_TASKQ_1THREAD, MINCLSYSPRI, 1,
			    ibmf_taskq_max_tasks, TASKQ_PREPOPULATE);
		else
			ibmf_clientp->ic_send_taskq = taskq_create(buf,
			    IBMF_TASKQ_NTHREADS, MINCLSYSPRI, 1,
			    ibmf_taskq_max_tasks,
			    TASKQ_DYNAMIC | TASKQ_PREPOPULATE);
		if (ibmf_clientp->ic_send_taskq == NULL) {
			cv_destroy(&ibmf_clientp->ic_recv_cb_teardown_cv);
			mutex_destroy(&ibmf_clientp->ic_mutex);
			mutex_destroy(&ibmf_clientp->ic_msg_mutex);
			mutex_destroy(&ibmf_clientp->ic_kstat_mutex);
			kmem_free((void *)ibmf_clientp, sizeof (ibmf_client_t));
			IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_alloc_client_err, IBMF_TNF_ERROR, "", "%s\n",
			    tnf_string, msg, buf);
			IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_alloc_client_end, IBMF_TNF_TRACE, "",
			    "ibmf_i_alloc_client() exit\n");
			return (IBMF_NO_RESOURCES);
		}
	}
	ibmf_clientp->ic_init_state_class |= IBMF_CI_INIT_SEND_TASKQ_DONE;

	(void) sprintf(buf, "r%08X_0x%08X",
	    (uint32_t)client_infop->ir_ci_guid, client_infop->ir_client_class);

	/* create a taskq to handle receive completions on reg flags */
	if ((flags & IBMF_REG_FLAG_NO_OFFLOAD) == 0) {
		if (flags & IBMF_REG_FLAG_SINGLE_OFFLOAD)
			ibmf_clientp->ic_recv_taskq = taskq_create(buf,
			    IBMF_TASKQ_1THREAD, MINCLSYSPRI, 1,
			    ibmf_taskq_max_tasks, TASKQ_PREPOPULATE);
		else
			ibmf_clientp->ic_recv_taskq = taskq_create(buf,
			    IBMF_TASKQ_NTHREADS, MINCLSYSPRI, 1,
			    ibmf_taskq_max_tasks,
			    TASKQ_DYNAMIC | TASKQ_PREPOPULATE);
		if (ibmf_clientp->ic_recv_taskq == NULL) {
			cv_destroy(&ibmf_clientp->ic_recv_cb_teardown_cv);
			mutex_destroy(&ibmf_clientp->ic_mutex);
			mutex_destroy(&ibmf_clientp->ic_msg_mutex);
			mutex_destroy(&ibmf_clientp->ic_kstat_mutex);
			taskq_destroy(ibmf_clientp->ic_send_taskq);
			kmem_free((void *)ibmf_clientp, sizeof (ibmf_client_t));
			IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_alloc_client_err, IBMF_TNF_ERROR, "", "%s\n",
			    tnf_string, msg, buf);
			IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_alloc_client_end, IBMF_TNF_TRACE, "",
			    "ibmf_i_alloc_client() exit\n");
			return (IBMF_NO_RESOURCES);
		}
	}
	ibmf_clientp->ic_init_state_class |= IBMF_CI_INIT_RECV_TASKQ_DONE;
	ibmf_clientp->ic_client_info.ci_guid = client_infop->ir_ci_guid;
	ibmf_clientp->ic_client_info.port_num = client_infop->ir_port_num;

	/* Get the base LID */
	(void) ibt_get_port_state_byguid(ibmf_clientp->ic_client_info.ci_guid,
	    ibmf_clientp->ic_client_info.port_num, NULL,
	    &ibmf_clientp->ic_base_lid);

	ibmf_clientp->ic_client_info.client_class =
	    client_infop->ir_client_class;

	/* set up the per client ibmf kstats */
	(void) sprintf(buf, "ibmf_%016" PRIx64 "_%d_%X_stat",
	    client_infop->ir_ci_guid, client_infop->ir_port_num,
	    client_infop->ir_client_class);
	if ((ibmf_clientp->ic_kstatp = kstat_create("ibmf", 0, buf, "misc",
	    KSTAT_TYPE_NAMED, sizeof (ibmf_kstat_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_WRITABLE)) == NULL) {
		cv_destroy(&ibmf_clientp->ic_recv_cb_teardown_cv);
		mutex_destroy(&ibmf_clientp->ic_mutex);
		mutex_destroy(&ibmf_clientp->ic_msg_mutex);
		mutex_destroy(&ibmf_clientp->ic_kstat_mutex);
		if ((flags & IBMF_REG_FLAG_NO_OFFLOAD) == 0) {
			taskq_destroy(ibmf_clientp->ic_send_taskq);
			taskq_destroy(ibmf_clientp->ic_recv_taskq);
		}
		kmem_free((void *)ibmf_clientp, sizeof (ibmf_client_t));
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_alloc_client_err, IBMF_TNF_ERROR, "", "%s\n",
		    tnf_string, msg, "kstat creation failed");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_alloc_client_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_alloc_client() exit\n");
		return (IBMF_NO_RESOURCES);
	}
	ksp = (ibmf_kstat_t *)ibmf_clientp->ic_kstatp->ks_data;
	kstat_named_init(&ksp->msgs_alloced, "messages_allocated",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->msgs_active, "messages_active",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->msgs_sent, "messages_sent", KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->msgs_received, "messages_received",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->sends_active, "sends_active", KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->recvs_active, "receives_active",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->ud_dests_alloced, "ud_dests_allocated",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->alt_qps_alloced, "alt_qps_allocated",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->send_cb_active, "send_callbacks_active",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->recv_cb_active, "receive_callbacks_active",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->recv_bufs_alloced, "receive_bufs_allocated",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->msg_allocs_failed, "msg_allocs_failed",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->uddest_allocs_failed, "uddest_allocs_failed",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->alt_qp_allocs_failed, "alt_qp_allocs_failed",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->send_pkt_failed, "send_pkt_failed",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&ksp->rmpp_errors, "rmpp_errors",
	    KSTAT_DATA_UINT32);

	kstat_install(ibmf_clientp->ic_kstatp);

	*clientpp = ibmf_clientp;

	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*ibmf_clientp))

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_alloc_client_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_alloc_client() exit\n");

	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_free_client():
 *	Free up the client structure and release resources
 */
void
ibmf_i_free_client(ibmf_client_t *clientp)
{
	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_client_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_free_client() enter, clientp = %p\n",
	    tnf_opaque, clientp, clientp);

	/* delete the general ibmf kstats */
	if (clientp->ic_kstatp != NULL) {
		kstat_delete(clientp->ic_kstatp);
		clientp->ic_kstatp = NULL;
	}

	/* release references and destroy the resources */
	if (clientp->ic_init_state_class & IBMF_CI_INIT_SEND_TASKQ_DONE) {
		if ((clientp->ic_reg_flags & IBMF_REG_FLAG_NO_OFFLOAD) == 0) {
			taskq_destroy(clientp->ic_send_taskq);
		}
		clientp->ic_init_state_class &= ~IBMF_CI_INIT_SEND_TASKQ_DONE;
	}

	if (clientp->ic_init_state_class & IBMF_CI_INIT_RECV_TASKQ_DONE) {
		if ((clientp->ic_reg_flags & IBMF_REG_FLAG_NO_OFFLOAD) == 0) {
			taskq_destroy(clientp->ic_recv_taskq);
		}
		clientp->ic_init_state_class &= ~IBMF_CI_INIT_RECV_TASKQ_DONE;
	}

	mutex_destroy(&clientp->ic_mutex);
	mutex_destroy(&clientp->ic_msg_mutex);
	mutex_destroy(&clientp->ic_kstat_mutex);
	cv_destroy(&clientp->ic_recv_cb_teardown_cv);
	kmem_free((void *)clientp, sizeof (ibmf_client_t));

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_client_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_free_client() exit\n");
}

/*
 * ibmf_i_validate_classes_and_port():
 *	Validate the class type and get the client structure
 */
int
ibmf_i_validate_classes_and_port(ibmf_ci_t *ibmf_cip,
    ibmf_register_info_t *client_infop)
{
	ibmf_client_t		*ibmf_clientp;
	int			status;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_validate_classes_and_port_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_validate_classes_and_port() enter, cip = %p, "
	    "clientp = %p\n", tnf_opaque, cip, ibmf_cip,
	    tnf_opaque, client_infop, client_infop);

	/*
	 * the Solaris implementation of IBMF does not support
	 * the UNIVERSAL_CLASS
	 */
	if (client_infop->ir_client_class == UNIVERSAL_CLASS) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_validate_classes_and_port_err, IBMF_TNF_ERROR, "",
		    "%s\n", tnf_string, msg,
		    "UNIVERSAL class is not supported");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_validate_classes_and_port_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_validate_classes_and_port() exit\n");
		return (IBMF_NOT_SUPPORTED);
	}

	/*
	 * Check if the client context already exists on the list
	 * maintained in the CI context. If it is, then the client class
	 * has already been registered for.
	 */
	status = ibmf_i_lookup_client_by_info(ibmf_cip, client_infop,
	    &ibmf_clientp);
	if (status != IBMF_SUCCESS) {
		/* client class has not been previously registered for */
		status = IBMF_SUCCESS;
	} else {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_validate_classes_and_port_err, IBMF_TNF_ERROR, "",
		    "client already registered, class = 0x%X\n",
		    tnf_uint, class, client_infop->ir_client_class);
		status = IBMF_PORT_IN_USE;
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_validate_classes_and_port_end, IBMF_TNF_TRACE, "",
	    "ibmf_i_validate_classes_and_port() exit\n");
	return (status);
}

/*
 * ibmf_i_lookup_client_by_info():
 *	Get the client structure from the list
 */
static int
ibmf_i_lookup_client_by_info(ibmf_ci_t *ibmf_cip,
    ibmf_register_info_t *ir_client, ibmf_client_t **clientpp)
{
	ibmf_client_t *clientp;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_lookup_client_by_info_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_lookup_client_by_info() enter, cip = %p, clientinfo = %p\n",
	    tnf_opaque, cip, ibmf_cip, tnf_opaque, clientinfo, ir_client);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_clients_mutex));

	/*
	 * walk the CI's client list searching for one with the specified class
	 */
	mutex_enter(&ibmf_cip->ci_clients_mutex);
	clientp = ibmf_cip->ci_clients;
	while (clientp != NULL) {
		ibmf_client_info_t *tmp = &clientp->ic_client_info;
		if (tmp->client_class == ir_client->ir_client_class &&
		    ir_client->ir_client_class != UNIVERSAL_CLASS &&
		    tmp->ci_guid == ir_client->ir_ci_guid &&
		    tmp->port_num == ir_client->ir_port_num) {
			/* found our match */
			break;
		}
		clientp = clientp->ic_next;
	}
	mutex_exit(&ibmf_cip->ci_clients_mutex);

	if (clientp != NULL) {
		*clientpp = clientp;
		IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_lookup_client_by_info_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_lookup_client_by_info(): clientp = %p\n",
		    tnf_opaque, clientp, clientp);
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_lookup_client_by_info_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_lookup_client_by_info() exit\n");
		return (IBMF_FAILURE);
	}
}

/*
 * ibmf_i_add_client():
 *	Add a new client to the client list
 */
void
ibmf_i_add_client(ibmf_ci_t *ibmf_cip, ibmf_client_t *ibmf_clientp)
{
	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_add_start,
	    IBMF_TNF_TRACE, "",
	    "ibmf_i_add_client() enter, cip = %p, clientp = %p\n",
	    tnf_opaque, ibmf_ci, ibmf_cip, tnf_opaque, client, ibmf_clientp);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_clients_mutex));

	mutex_enter(&ibmf_cip->ci_clients_mutex);
	ibmf_clientp->ic_next = NULL;
	ibmf_clientp->ic_prev = ibmf_cip->ci_clients_last;
	if (ibmf_cip->ci_clients == NULL) {
		ibmf_cip->ci_clients = ibmf_clientp;
	}
	if (ibmf_cip->ci_clients_last) {
		ibmf_cip->ci_clients_last->ic_next = ibmf_clientp;
	}
	ibmf_cip->ci_clients_last = ibmf_clientp;
	mutex_exit(&ibmf_cip->ci_clients_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_add_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_add_client() exit\n");
}

/*
 * ibmf_i_delete_client():
 *	Delete a client from the client list
 */
void
ibmf_i_delete_client(ibmf_ci_t *ibmf_cip, ibmf_client_t *ibmf_clientp)
{
	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_delete_client_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_delete_client() enter, "
	    "ibmf_i_delete_client() enter, cip = %p, clientp = %p\n",
	    tnf_opaque, ibmf_ci, ibmf_cip, tnf_opaque, client, ibmf_clientp);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_clients_mutex));

	mutex_enter(&ibmf_cip->ci_clients_mutex);
	if (ibmf_clientp->ic_next)
		ibmf_clientp->ic_next->ic_prev = ibmf_clientp->ic_prev;

	if (ibmf_clientp->ic_prev)
		ibmf_clientp->ic_prev->ic_next = ibmf_clientp->ic_next;

	if (ibmf_cip->ci_clients == ibmf_clientp) {
		ibmf_cip->ci_clients = ibmf_clientp->ic_next;
	}
	if (ibmf_cip->ci_clients_last == ibmf_clientp) {
		ibmf_cip->ci_clients_last = ibmf_clientp->ic_prev;
	}
	mutex_exit(&ibmf_cip->ci_clients_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_delete_client_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_delete_client() exit\n");
}

/*
 * ibmf_i_get_qp():
 *	Get the QP structure based on the client class
 */
int
ibmf_i_get_qp(ibmf_ci_t *ibmf_cip, uint_t port_num, ibmf_client_type_t class,
    ibmf_qp_t **qppp)
{
	ibmf_qp_t		*qpp;
	int			qp_num, status = IBMF_SUCCESS;

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_qp_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_get_qp() enter, cip = %p, "
	    "port = %d, class = %x\n", tnf_opaque, ibmf_ci, ibmf_cip,
	    tnf_int, port, port_num, tnf_opaque, class, class);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_mutex));

	mutex_enter(&ibmf_cip->ci_mutex);

	/*
	 * walk through the list of qps on this ci, looking for one that
	 * corresponds to the type and class the caller is interested in.
	 * If it is not there, we need allocate it from the transport. Since
	 * qp0 & qp1 can only be allocated once, we maintain a reference count
	 * and call the transport for allocation iff the ref count is 0.
	 */
	qp_num = (class == SUBN_AGENT || class == SUBN_MANAGER) ? 0 : 1;

	qpp = ibmf_cip->ci_qp_list;
	while (qpp != NULL) {
		if (port_num == qpp->iq_port_num && qp_num == qpp->iq_qp_num)
			break;
		qpp = qpp->iq_next;
	}

	if (qpp == NULL) {
		/*
		 * allocate qp and add it the qp list; recheck to
		 * catch races
		 */
		ibmf_qp_t *tqpp;

		mutex_exit(&ibmf_cip->ci_mutex);

		tqpp = (ibmf_qp_t *)kmem_zalloc(sizeof (ibmf_qp_t), KM_SLEEP);

		/* check the list under lock */
		mutex_enter(&ibmf_cip->ci_mutex);

		qpp = ibmf_cip->ci_qp_list;
		while (qpp != NULL) {
			if (port_num == qpp->iq_port_num && qp_num ==
			    qpp->iq_qp_num)
				break;
			qpp = qpp->iq_next;
		}

		if (qpp != NULL) {
			/* some one raced past us and added to the list */
			kmem_free((void *)tqpp, sizeof (ibmf_qp_t));
		} else {
			/* add this to the qp list */
			qpp = tqpp;
			_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*qpp))
			qpp->iq_next = NULL;
			if (ibmf_cip->ci_qp_list == NULL)
				ibmf_cip->ci_qp_list = qpp;
			if (ibmf_cip->ci_qp_list_tail != NULL)
				ibmf_cip->ci_qp_list_tail->iq_next = qpp;
			ibmf_cip->ci_qp_list_tail = qpp;
			qpp->iq_port_num = port_num;
			qpp->iq_qp_num = qp_num;
			qpp->iq_flags = IBMF_QP_FLAGS_INVALID;
			mutex_init(&qpp->iq_mutex, NULL, MUTEX_DRIVER, NULL);
		}
	}

	/* we now have a QP context */
	for (;;) {
		if (qpp->iq_flags == IBMF_QP_FLAGS_INITING) {

			/* block till qp is in VALID state */
			cv_wait(&ibmf_cip->ci_qp_cv, &ibmf_cip->ci_mutex);
			continue;

		}

		if (qpp->iq_flags == IBMF_QP_FLAGS_UNINITING) {

			/* block till qp is in INVALID state */
			cv_wait(&ibmf_cip->ci_qp_cv, &ibmf_cip->ci_mutex);
			continue;
		}

		if (qpp->iq_flags == IBMF_QP_FLAGS_INVALID) {
			if ((status = ibmf_i_init_qp(ibmf_cip, qpp)) !=
			    IBMF_SUCCESS) {
				ibmf_qp_t *tqpp;

				/*
				 * Remove the QP context from the CI's list.
				 * Only initialized QPs should be on the list.
				 * We know that this QP is on the list, so
				 * the list is not empty.
				 */
				tqpp = ibmf_cip->ci_qp_list;
				if (tqpp == qpp) {
					/* Only QP context on the list */
					ibmf_cip->ci_qp_list = NULL;
					ibmf_cip->ci_qp_list_tail = NULL;
				}

				/* Find the QP context before the last one */
				if (tqpp != qpp) {
					while (tqpp->iq_next != qpp) {
						tqpp = tqpp->iq_next;
					}

					/*
					 * We are at the second last element of
					 * the list. Readjust the tail pointer.
					 * Remove the last element from the
					 * list.
					 */
					tqpp->iq_next = NULL;
					ibmf_cip->ci_qp_list_tail = tqpp;
				}

				/* Free up the QP context */
				kmem_free((void *)qpp, sizeof (ibmf_qp_t));

				break;
			}
			continue;
		}

		if (qpp->iq_flags == IBMF_QP_FLAGS_INITED) {
			qpp->iq_qp_ref++;
			break;
		}
	}

	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*qpp))

	mutex_exit(&ibmf_cip->ci_mutex);

	if (status == IBMF_SUCCESS) {
		*qppp = qpp;
		IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_qp() exit "
		    "qp_handle = %p\n", tnf_opaque, qp_handle, qpp);
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_get_qp_err,
		    IBMF_TNF_ERROR, "", "%s\n", tnf_string, msg,
		    "ibmf_i_get_qp(): qp_not found");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_qp() exit\n");
		return (status);
	}
}

/*
 * ibmf_i_release_qp():
 *	Drop the reference count on the QP structure
 */
void
ibmf_i_release_qp(ibmf_ci_t *ibmf_cip, ibmf_qp_t **qppp)
{
	ibmf_qp_t	*qpp;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_release_qp_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_release_qp() enter, cip = %p, "
	    "qpp = %p\n", tnf_opaque, cip, ibmf_cip, tnf_opaque, qpp, *qppp);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_mutex));

	mutex_enter(&ibmf_cip->ci_mutex);
	qpp = *qppp;
	qpp->iq_qp_ref--;
	if (qpp->iq_qp_ref == 0)
		ibmf_i_uninit_qp(ibmf_cip, qpp);
	mutex_exit(&ibmf_cip->ci_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_release_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_release_qp() exit\n");
}

/*
 * ibmf_i_init_qp():
 *	Set up the QP context, request a QP from the IBT framework
 *	and initialize it
 */
static int
ibmf_i_init_qp(ibmf_ci_t *ibmf_cip, ibmf_qp_t *qpp)
{
	ibt_sqp_type_t		qp_type;
	ibt_qp_alloc_attr_t	qp_attrs;
	ibt_qp_hdl_t		qp_handle;
	ibt_qp_info_t		qp_modify_attr;
	ibt_status_t		ibt_status;
	int			i, status;

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qp_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_qp() enter, cip = %p, "
	    "port = %d, qp = %d\n", tnf_opaque, ibmf_ci, ibmf_cip, tnf_int,
	    port, qpp->iq_port_num, tnf_int, num, qpp->iq_qp_num);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(qpp->iq_qp_handle))

	ASSERT(MUTEX_HELD(&ibmf_cip->ci_mutex));

	qpp->iq_flags = IBMF_QP_FLAGS_INITING;
	mutex_exit(&ibmf_cip->ci_mutex);
	if (qpp->iq_qp_handle) {	/* closed but not yet freed */
		ibt_status = ibt_free_qp(qpp->iq_qp_handle);
		if (ibt_status != IBT_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_init_qp_err, IBMF_TNF_ERROR, "",
			    "%s, status = %d\n", tnf_string, msg,
			    "ibt_free_qp returned error",
			    tnf_uint, ibt_status, ibt_status);
		}
		qpp->iq_qp_handle = NULL;
	}
	ASSERT(qpp->iq_qp_num == 0 || qpp->iq_qp_num == 1);
	if (qpp->iq_qp_num == 0)
		qp_type = IBT_SMI_SQP;
	else
		qp_type = IBT_GSI_SQP;
	qp_attrs.qp_scq_hdl = ibmf_cip->ci_cq_handle;
	qp_attrs.qp_rcq_hdl = ibmf_cip->ci_cq_handle;
	qp_attrs.qp_pd_hdl = ibmf_cip->ci_pd;
	qp_attrs.qp_sizes.cs_sq_sgl = 1;
	qp_attrs.qp_sizes.cs_rq_sgl = IBMF_MAX_RQ_WR_SGL_ELEMENTS;
	qp_attrs.qp_sizes.cs_sq = ibmf_send_wqes_posted_per_qp;
	qp_attrs.qp_sizes.cs_rq = ibmf_recv_wqes_posted_per_qp;
	qp_attrs.qp_flags = IBT_ALL_SIGNALED;
	qp_attrs.qp_alloc_flags = IBT_QP_NO_FLAGS;

	/* call the IB transport to allocate a special QP */
	ibt_status = ibt_alloc_special_qp(ibmf_cip->ci_ci_handle,
	    qpp->iq_port_num, qp_type, &qp_attrs, NULL, &qp_handle);
	if (ibt_status != IBT_SUCCESS) {
		mutex_enter(&ibmf_cip->ci_mutex);
		qpp->iq_flags = IBMF_QP_FLAGS_INVALID;
		cv_broadcast(&ibmf_cip->ci_qp_cv);
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_qp_err,
		    IBMF_TNF_ERROR, "", "ibmf_i_init_qp() error status = %d\n",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_init_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/* initialize qpp */
	qpp->iq_qp_handle = qp_handle;
	qp_modify_attr.qp_trans = IBT_UD_SRV;
	qp_modify_attr.qp_flags = IBT_CEP_NO_FLAGS;

	/* get the pkey index for the specified pkey */
	if (ibmf_i_get_pkeyix(ibmf_cip->ci_ci_handle, IBMF_P_KEY_DEF_LIMITED,
	    qpp->iq_port_num, &qp_modify_attr.qp_transport.ud.ud_pkey_ix) !=
	    IBMF_SUCCESS) {
		ibt_status = ibt_free_qp(qpp->iq_qp_handle);
		if (ibt_status != IBT_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_init_qp_err, IBMF_TNF_ERROR, "",
			    "%s, status = %d\n", tnf_string, msg,
			    "ibt_free_qp returned error",
			    tnf_uint, ibt_status, ibt_status);
		}
		mutex_enter(&ibmf_cip->ci_mutex);
		qpp->iq_flags = IBMF_QP_FLAGS_INVALID;
		cv_broadcast(&ibmf_cip->ci_qp_cv);
		IBMF_TRACE_0(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_qp_err,
		    IBMF_TNF_ERROR, "", "ibmf_init_qp(): failed to get "
		    "pkey index\n");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_init_qp() exit\n");
		return (IBMF_FAILURE);
	}
	qp_modify_attr.qp_transport.ud.ud_sq_psn = 0;
	qp_modify_attr.qp_transport.ud.ud_port = qpp->iq_port_num;
	qp_modify_attr.qp_transport.ud.ud_qkey = IBMF_MGMT_Q_KEY;

	/* call the IB transport to initialize the QP */
	ibt_status = ibt_initialize_qp(qp_handle, &qp_modify_attr);
	if (ibt_status != IBT_SUCCESS) {
		ibt_status = ibt_free_qp(qpp->iq_qp_handle);
		if (ibt_status != IBT_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_init_qp_err, IBMF_TNF_ERROR, "",
			    "%s, status = %d\n", tnf_string, msg,
			    "ibt_free_qp returned error",
			    tnf_uint, ibt_status, ibt_status);
		}
		mutex_enter(&ibmf_cip->ci_mutex);
		qpp->iq_flags = IBMF_QP_FLAGS_INVALID;
		cv_broadcast(&ibmf_cip->ci_qp_cv);
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1, ibmf_i_init_qp_err,
		    IBMF_TNF_ERROR, "", "ibmf_init_qp(): error status = %d\n",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_init_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/* post receive wqes to the RQ to handle unsolicited inbound packets  */
	for (i = 0; i < ibmf_recv_wqes_per_port; i++) {
		status =  ibmf_i_post_recv_buffer(ibmf_cip, qpp,
		    B_TRUE, IBMF_QP_HANDLE_DEFAULT);
		if (status != IBMF_SUCCESS) {
			IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L1,
			    ibmf_i_init_qp, IBMF_TNF_TRACE, "",
			    "%s\n", tnf_string, msg, "ibmf_i_init_qp(): "
			    "ibmf_i_post_recv_buffer() failed");
		}
	}
	mutex_enter(&ibmf_cip->ci_mutex);

	/* set the state and signal blockers */
	qpp->iq_flags = IBMF_QP_FLAGS_INITED;
	cv_broadcast(&ibmf_cip->ci_qp_cv);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_qp() exit\n");
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_uninit_qp():
 *	Invalidate the QP context
 */
static void
ibmf_i_uninit_qp(ibmf_ci_t *ibmf_cip, ibmf_qp_t *qpp)
{
	ibt_status_t		status;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_qp_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_qp() enter, cip = %p "
	    "qpp = %p\n", tnf_opaque, cip, ibmf_cip, tnf_opaque, qpp, qpp);

	ASSERT(MUTEX_HELD(&ibmf_cip->ci_mutex));

	/* mark the state as uniniting */
	ASSERT(qpp->iq_qp_ref == 0);
	qpp->iq_flags = IBMF_QP_FLAGS_UNINITING;
	mutex_exit(&ibmf_cip->ci_mutex);

	/* note: we ignore error values from ibt_flush_qp */
	status = ibt_flush_qp(qpp->iq_qp_handle);
	if (status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L2,
		    ibmf_i_uninit_qp_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_uninit_qp(): %s, status = %d\n", tnf_string, msg,
		    "ibt_flush_qp returned error", tnf_int, status, status);
	}

	/* mark state as INVALID and signal any blockers */
	mutex_enter(&ibmf_cip->ci_mutex);
	qpp->iq_flags = IBMF_QP_FLAGS_INVALID;
	cv_broadcast(&ibmf_cip->ci_qp_cv);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_uninit_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_uninit_qp() exit\n");
}

/*
 * ibmf_i_alloc_msg():
 *	Allocate and set up a message context
 */
int
ibmf_i_alloc_msg(ibmf_client_t *clientp, ibmf_msg_impl_t **msgp, int km_flags)
{
	ibmf_msg_impl_t *msgimplp;

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_alloc_msg_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_alloc_msg() enter, clientp = %p, msg = %p, "
	    " kmflags = %d\n", tnf_opaque, clientp, clientp, tnf_opaque, msg,
	    *msgp, tnf_int, km_flags, km_flags);

	/* allocate the message context */
	msgimplp = (ibmf_msg_impl_t *)kmem_zalloc(sizeof (ibmf_msg_impl_t),
	    km_flags);
	if (msgimplp != NULL) {
		if (km_flags == KM_SLEEP) {
			ibmf_i_pop_ud_dest_thread(clientp->ic_myci);
		}
	} else {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_alloc_msg_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_alloc_msg(): %s\n",
		    tnf_string, msg, "kmem_xalloc failed");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_alloc_msg_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_alloc_msg() exit\n");
		return (IBMF_NO_RESOURCES);
	}

	*msgp = msgimplp;
	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_alloc_msg_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_alloc_msg() exit\n");
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_free_msg():
 *	frees up all buffers allocated by IBMF for
 * 	this message context, and then frees up the context
 */
void
ibmf_i_free_msg(ibmf_msg_impl_t *msgimplp)
{
	ibmf_msg_bufs_t *msgbufp = &msgimplp->im_msgbufs_recv;
	ibmf_client_t *clientp = (ibmf_client_t *)msgimplp->im_client;
	uint32_t	cl_hdr_sz, cl_hdr_off;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_free_msg_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_free_msg() enter, msg = %p\n", tnf_opaque, msg, msgimplp);

	/* free up the UD destination resource */
	if (msgimplp->im_ibmf_ud_dest != NULL) {
		ibmf_i_free_ud_dest(clientp, msgimplp);
		ibmf_i_clean_ud_dest_list(clientp->ic_myci, B_FALSE);
	}

	/* free up the receive buffer if allocated previously */
	if (msgbufp->im_bufs_mad_hdr != NULL) {
		ibmf_i_mgt_class_to_hdr_sz_off(
		    msgbufp->im_bufs_mad_hdr->MgmtClass,
		    &cl_hdr_sz, &cl_hdr_off);
		kmem_free(msgbufp->im_bufs_mad_hdr, sizeof (ib_mad_hdr_t) +
		    cl_hdr_off + msgbufp->im_bufs_cl_hdr_len +
		    msgbufp->im_bufs_cl_data_len);
		mutex_enter(&clientp->ic_kstat_mutex);
		IBMF_SUB32_KSTATS(clientp, recv_bufs_alloced, 1);
		mutex_exit(&clientp->ic_kstat_mutex);
	}

	/* destroy the message mutex */
	mutex_destroy(&msgimplp->im_mutex);

	/* free the message context */
	kmem_free(msgimplp, sizeof (ibmf_msg_impl_t));

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_msg_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_free_msg() exit\n");
}

/*
 * ibmf_i_msg_transport():
 *	Send a message posted by the IBMF client using the RMPP protocol
 *	if specified
 */
int
ibmf_i_msg_transport(ibmf_client_t *clientp, ibmf_qp_handle_t ibmf_qp_handle,
    ibmf_msg_impl_t *msgimplp, int blocking)
{
	ib_mad_hdr_t	*madhdrp;
	ibmf_msg_bufs_t *msgbufp, *smsgbufp;
	uint32_t	cl_hdr_sz, cl_hdr_off;
	boolean_t	isDS = 0; /* double sided (sequenced) transaction */
	boolean_t	error = B_FALSE;
	int		status = IBMF_SUCCESS;
	uint_t		refcnt;
	char		errmsg[128];
	timeout_id_t	msg_rp_unset_id, msg_tr_unset_id;

	IBMF_TRACE_4(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_msg_transport_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): clientp = 0x%p, "
	    "qphdl = 0x%p, msgp = 0x%p, block = %d\n",
	    tnf_opaque, clientp, clientp, tnf_opaque, qphdl, ibmf_qp_handle,
	    tnf_opaque, msg, msgimplp, tnf_uint, block, blocking);

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*msgimplp, *msgbufp))

	mutex_enter(&msgimplp->im_mutex);

	madhdrp = msgimplp->im_msgbufs_send.im_bufs_mad_hdr;
	msgbufp = &msgimplp->im_msgbufs_recv;
	smsgbufp = &msgimplp->im_msgbufs_send;

	/*
	 * check if transp_op_flags specify that the transaction is
	 * a single packet, then the size of the message header + data
	 * does not exceed 256 bytes
	 */
	if ((msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_RMPP) == 0) {
		ibmf_i_mgt_class_to_hdr_sz_off(
		    smsgbufp->im_bufs_mad_hdr->MgmtClass,
		    &cl_hdr_sz, &cl_hdr_off);

		if ((sizeof (ib_mad_hdr_t) + cl_hdr_off +
		    smsgbufp->im_bufs_cl_hdr_len +
		    smsgbufp->im_bufs_cl_data_len) > IBMF_MAD_SIZE) {
			mutex_exit(&msgimplp->im_mutex);
			(void) sprintf(errmsg,
			    "Non-RMPP message size is too large");
			error = B_TRUE;
			status = IBMF_BAD_SIZE;
			goto bail;
		}
	}

	/* more message context initialization */
	msgimplp->im_qp_hdl 	= ibmf_qp_handle;
	msgimplp->im_tid	= b2h64(madhdrp->TransactionID);
	msgimplp->im_mgt_class 	= madhdrp->MgmtClass;
	msgimplp->im_unsolicited = B_FALSE;
	msgimplp->im_trans_state_flags = IBMF_TRANS_STATE_FLAG_UNINIT;
	bzero(&msgimplp->im_rmpp_ctx, sizeof (ibmf_rmpp_ctx_t));
	msgimplp->im_rmpp_ctx.rmpp_state = IBMF_RMPP_STATE_UNDEFINED;
	msgimplp->im_rmpp_ctx.rmpp_respt = IBMF_RMPP_DEFAULT_RRESPT;
	msgimplp->im_rmpp_ctx.rmpp_retry_cnt = 0;
	msgimplp->im_ref_count = 0;
	msgimplp->im_pending_send_compls = 0;
	IBMF_MSG_INCR_REFCNT(msgimplp);
	if (msgimplp->im_retrans.retrans_retries == 0)
		msgimplp->im_retrans.retrans_retries = IBMF_RETRANS_DEF_RETRIES;
	if (msgimplp->im_retrans.retrans_rtv == 0)
		msgimplp->im_retrans.retrans_rtv = IBMF_RETRANS_DEF_RTV;
	if (msgimplp->im_retrans.retrans_rttv == 0)
		msgimplp->im_retrans.retrans_rttv = IBMF_RETRANS_DEF_RTTV;

	IBMF_TRACE_5(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): %s, msgp = 0x%p, "
	    "class = 0x%x, method = 0x%x, attributeID = 0x%x\n",
	    tnf_string, msg, "Added message", tnf_opaque, msgimplp,
	    msgimplp, tnf_opaque, class, msgimplp->im_mgt_class, tnf_opaque,
	    method, madhdrp->R_Method, tnf_opaque, attrib_id,
	    b2h16(madhdrp->AttributeID));

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): msgp = 0x%p, "
	    "TID = 0x%p, transp_op_flags = 0x%x\n",
	    tnf_opaque, msgimplp, msgimplp, tnf_opaque, tid, msgimplp->im_tid,
	    tnf_uint, transp_op_flags, msgimplp->im_transp_op_flags);

	/*
	 * Do not allow reuse of a message where the receive buffers are
	 * being used as send buffers if this is a sequenced transaction
	 */
	if ((madhdrp == msgbufp->im_bufs_mad_hdr) &&
	    (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_SEQ)) {
		IBMF_MSG_DECR_REFCNT(msgimplp);
		mutex_exit(&msgimplp->im_mutex);
		(void) sprintf(errmsg,
		    "Send and Recv buffers are the same for sequenced"
		    " transaction");
		error = B_TRUE;
		status = IBMF_REQ_INVALID;
		goto bail;
	}

	/* set transaction flags */
	if (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_SEQ)
		msgimplp->im_flags |= IBMF_MSG_FLAGS_SEQUENCED;

	if (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_RMPP)
		msgimplp->im_flags |= IBMF_MSG_FLAGS_SEND_RMPP;
	else
		msgimplp->im_flags |= IBMF_MSG_FLAGS_NOT_RMPP;

	/* free recv buffers if this is a reused message */
	if ((msgbufp->im_bufs_mad_hdr != NULL) &&
	    (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_SEQ)) {

		IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
		    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): %s, "
		    "msgp = 0x%p, mad_hdrp = 0x%p\n", tnf_string, msg,
		    "Freeing recv buffer for reused message",
		    tnf_opaque, msgimplp, msgimplp,
		    tnf_opaque, mad_hdr, msgbufp->im_bufs_mad_hdr);

		ibmf_i_mgt_class_to_hdr_sz_off(
		    msgbufp->im_bufs_mad_hdr->MgmtClass,
		    &cl_hdr_sz, &cl_hdr_off);

		kmem_free(msgbufp->im_bufs_mad_hdr, sizeof (ib_mad_hdr_t) +
		    cl_hdr_off + msgbufp->im_bufs_cl_hdr_len +
		    msgbufp->im_bufs_cl_data_len);

		msgbufp->im_bufs_mad_hdr = NULL;
		msgbufp->im_bufs_cl_hdr = NULL;
		msgbufp->im_bufs_cl_hdr_len = 0;
		msgbufp->im_bufs_cl_data = NULL;
		msgbufp->im_bufs_cl_data_len = 0;
	}

	mutex_exit(&msgimplp->im_mutex);

	/* initialize (and possibly allocate) the address handle */
	status = ibmf_i_alloc_ud_dest(clientp, msgimplp,
	    &msgimplp->im_ud_dest, blocking);
	if (status != IBMF_SUCCESS) {
		(void) sprintf(errmsg, "ibmf_i_alloc_ud_dest() failed");
		error = B_TRUE;
		goto bail;
	}

	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*msgimplp, *msgbufp))

	/* add the message to the client context's message list */
	ibmf_i_client_add_msg(clientp, msgimplp);

	mutex_enter(&msgimplp->im_mutex);

	/* no one should have touched our state */
	ASSERT(msgimplp->im_trans_state_flags == IBMF_TRANS_STATE_FLAG_UNINIT);

	/* transition out of uninit state */
	msgimplp->im_trans_state_flags = IBMF_TRANS_STATE_FLAG_INIT;

	IBMF_TRACE_5(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): msgp = 0x%p, "
	    "local_lid = 0x%x, remote_lid = 0x%x, remote_qpn = 0x%x, "
	    "block = %d\n", tnf_opaque, msgp, msgimplp,
	    tnf_uint, local_lid, msgimplp->im_local_addr.ia_local_lid,
	    tnf_uint, remote_lid, msgimplp->im_local_addr.ia_remote_lid,
	    tnf_uint, remote_qpn, msgimplp->im_local_addr.ia_remote_qno,
	    tnf_uint, blocking, blocking);

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport(): "
	    "unsetting timer %p %d\n", tnf_opaque, msgimplp, msgimplp,
	    tnf_opaque, timeout_id, msgimplp->im_rp_timeout_id);

	ASSERT(msgimplp->im_rp_timeout_id == 0);
	ASSERT(msgimplp->im_tr_timeout_id == 0);

	if ((msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_RMPP) == 0) {

		/* Non-RMPP transaction */

		status = ibmf_i_send_single_pkt(clientp, ibmf_qp_handle,
		    msgimplp, blocking);
		if (status != IBMF_SUCCESS) {
			IBMF_MSG_DECR_REFCNT(msgimplp);
			mutex_exit(&msgimplp->im_mutex);
			ibmf_i_client_rem_msg(clientp, msgimplp, &refcnt);
			(void) sprintf(errmsg, "Single packet send failed");
			error = B_TRUE;
			goto bail;
		}

	} else if (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_RMPP) {

		/* RMPP transaction */

		/* check if client supports RMPP traffic */
		if ((clientp->ic_reg_flags & IBMF_REG_FLAG_RMPP) == 0) {
			IBMF_MSG_DECR_REFCNT(msgimplp);
			mutex_exit(&msgimplp->im_mutex);
			ibmf_i_client_rem_msg(clientp, msgimplp, &refcnt);
			(void) sprintf(errmsg, "Class does not support RMPP");
			error = B_TRUE;
			status = IBMF_BAD_RMPP_OPT;
			goto bail;
		}

		/* for non-special QPs, check if QP supports RMPP traffic */
		if (ibmf_qp_handle != IBMF_QP_HANDLE_DEFAULT &&
		    (((ibmf_alt_qp_t *)ibmf_qp_handle)->isq_supports_rmpp ==
		    B_FALSE)) {
			IBMF_MSG_DECR_REFCNT(msgimplp);
			mutex_exit(&msgimplp->im_mutex);
			ibmf_i_client_rem_msg(clientp, msgimplp, &refcnt);
			(void) sprintf(errmsg, "QP does not support RMPP");
			error = B_TRUE;
			status = IBMF_BAD_RMPP_OPT;
			goto bail;
		}

		/* check if transaction is "double sided" (send and receive) */
		if (msgimplp->im_transp_op_flags & IBMF_MSG_TRANS_FLAG_SEQ)
			isDS = 1;

		status = ibmf_i_send_rmpp_pkts(clientp, ibmf_qp_handle,
		    msgimplp, isDS, blocking);
		if (status != IBMF_SUCCESS) {
			IBMF_MSG_DECR_REFCNT(msgimplp);
			mutex_exit(&msgimplp->im_mutex);
			ibmf_i_client_rem_msg(clientp, msgimplp, &refcnt);
			(void) sprintf(errmsg, "RMPP packets send failed");
			error = B_TRUE;
			goto bail;
		}
	}

	/*
	 * decrement the reference count so notify_client() can remove the
	 * message when it's ready
	 */
	IBMF_MSG_DECR_REFCNT(msgimplp);

	/* check if the transaction is a blocking transaction */
	if (blocking && ((msgimplp->im_trans_state_flags &
	    IBMF_TRANS_STATE_FLAG_SIGNALED) == 0)) {

		/* indicate that the tranaction is waiting */
		msgimplp->im_trans_state_flags |= IBMF_TRANS_STATE_FLAG_WAIT;

		IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
		    IBMF_TNF_TRACE, "",
		    "ibmf_i_msg_transport(): %s, msgp = 0x%p\n",
		    tnf_string, msg, "blocking for completion",
		    tnf_opaque, msgimplp, msgimplp);

		/* wait for transaction completion */
		cv_wait(&msgimplp->im_trans_cv, &msgimplp->im_mutex);

		IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L3, ibmf_i_msg_transport,
		    IBMF_TNF_TRACE, "",
		    "ibmf_i_msg_transport(): %s, msgp = 0x%p\n",
		    tnf_string, msg, "unblocking for completion",
		    tnf_opaque, msgimplp, msgimplp);

		/* clean up flags */
		msgimplp->im_trans_state_flags &= ~IBMF_TRANS_STATE_FLAG_WAIT;
		msgimplp->im_flags &= ~IBMF_MSG_FLAGS_BUSY;

		if (msgimplp->im_msg_status != IBMF_SUCCESS) {

			IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_msg_transport_err, IBMF_TNF_ERROR, "",
			    "ibmf_i_msg_transport(): msg_status = %d\n",
			    tnf_uint, msgstatus, msgimplp->im_msg_status);

			status = msgimplp->im_msg_status;
		}
	} else if (blocking && (msgimplp->im_trans_state_flags &
	    IBMF_TRANS_STATE_FLAG_SIGNALED)) {
		msgimplp->im_flags &= ~IBMF_MSG_FLAGS_BUSY;

		if (msgimplp->im_msg_status != IBMF_SUCCESS) {
			IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_msg_transport_err, IBMF_TNF_ERROR, "",
			    "ibmf_i_msg_transport(): msg_status = %d\n",
			    tnf_uint, msgstatus, msgimplp->im_msg_status);
			status = msgimplp->im_msg_status;
		}
	}

	msg_rp_unset_id = msg_tr_unset_id = 0;
	msg_rp_unset_id = msgimplp->im_rp_unset_timeout_id;
	msg_tr_unset_id = msgimplp->im_tr_unset_timeout_id;
	msgimplp->im_rp_unset_timeout_id = 0;
	msgimplp->im_tr_unset_timeout_id = 0;

	mutex_exit(&msgimplp->im_mutex);

	/* Unset the timers */
	if (msg_rp_unset_id != 0) {
		(void) untimeout(msg_rp_unset_id);
	}

	if (msg_tr_unset_id != 0) {
		(void) untimeout(msg_tr_unset_id);
	}

	/* increment kstats of the number of sent messages */
	mutex_enter(&clientp->ic_kstat_mutex);
	IBMF_ADD32_KSTATS(clientp, msgs_sent, 1);
	mutex_exit(&clientp->ic_kstat_mutex);

bail:
	if (error) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_msg_transport_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_msg_transport(): %s, msgp = 0x%p\n",
		    tnf_string, msg, errmsg, tnf_opaque, msgimplp, msgimplp);
	}

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,	ibmf_i_msg_transport_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_msg_transport() exit, status = %d\n",
	    tnf_uint, status, status);

	return (status);
}

/*
 * ibmf_i_init_msg():
 *	Initialize the message fields
 */
void
ibmf_i_init_msg(ibmf_msg_impl_t *msgimplp, ibmf_msg_cb_t trans_cb,
    void *trans_cb_arg, ibmf_retrans_t *retrans, boolean_t block)
{
	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_msg_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_msg() enter\n");

	_NOTE(ASSUMING_PROTECTED(msgimplp->im_trans_cb,
	    msgimplp->im_trans_cb_arg))

	if (block == B_TRUE)
		msgimplp->im_msg_flags |= IBMF_MSG_FLAGS_BLOCKING;
	msgimplp->im_trans_cb = trans_cb;
	msgimplp->im_trans_cb_arg = trans_cb_arg;

	bzero(&msgimplp->im_retrans, sizeof (ibmf_retrans_t));
	if (retrans != NULL) {
		bcopy((void *)retrans, (void *)&msgimplp->im_retrans,
		    sizeof (ibmf_retrans_t));
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_init_msg_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_init_msg() exit\n");
}

/*
 * ibmf_i_alloc_qp():
 *	Allocate a QP context for the alternate QPs
 */
int
ibmf_i_alloc_qp(ibmf_client_t *clientp, ib_pkey_t p_key, ib_qkey_t q_key,
    uint_t flags, ibmf_qp_handle_t *ibmf_qp_handlep)
{
	ibmf_ci_t		*ibmf_cip = clientp->ic_myci;
	ibt_qp_alloc_attr_t	qp_attrs;
	ibt_qp_info_t		qp_modify_attr;
	ibmf_alt_qp_t		*qp_ctx;
	uint16_t		pkey_ix;
	ibt_status_t		ibt_status;
	int			i, blocking;
	boolean_t		error = B_FALSE;
	int			status = IBMF_SUCCESS;
	char			errmsg[128];


	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_alloc_qp_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_alloc_qp() enter, clientp = %p, pkey = %x, qkey = %x \n",
	    tnf_opaque, clientp, clientp, tnf_uint, p_key, p_key,
	    tnf_uint, q_key, q_key);

	/*
	 * get the pkey index associated with this pkey if present in table
	 */
	if (ibmf_i_get_pkeyix(clientp->ic_ci_handle, p_key,
	    clientp->ic_client_info.port_num, &pkey_ix) != IBMF_SUCCESS) {
		(void) sprintf(errmsg, "pkey not in table, pkey = %x", p_key);
		error = B_TRUE;
		status = IBMF_FAILURE;
		goto bail;
	}

	/* allocate QP context memory */
	qp_ctx = (ibmf_alt_qp_t *)kmem_zalloc(sizeof (ibmf_alt_qp_t),
	    (flags & IBMF_ALLOC_SLEEP) ? KM_SLEEP : KM_NOSLEEP);
	if (qp_ctx == NULL) {
		(void) sprintf(errmsg, "failed to kmem_zalloc qp ctx");
		error = B_TRUE;
		status = IBMF_NO_RESOURCES;
		goto bail;
	}

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*qp_ctx));

	/* setup the qp attrs for the alloc call */
	qp_attrs.qp_scq_hdl = ibmf_cip->ci_alt_cq_handle;
	qp_attrs.qp_rcq_hdl = ibmf_cip->ci_alt_cq_handle;
	qp_attrs.qp_pd_hdl = ibmf_cip->ci_pd;
	qp_attrs.qp_sizes.cs_sq_sgl = IBMF_MAX_SQ_WR_SGL_ELEMENTS;
	qp_attrs.qp_sizes.cs_rq_sgl = IBMF_MAX_RQ_WR_SGL_ELEMENTS;
	qp_attrs.qp_sizes.cs_sq = ibmf_send_wqes_posted_per_qp;
	qp_attrs.qp_sizes.cs_rq = ibmf_recv_wqes_posted_per_qp;
	qp_attrs.qp_flags = IBT_ALL_SIGNALED;
	qp_attrs.qp_alloc_flags = IBT_QP_NO_FLAGS;

	/* request IBT for a qp with the desired attributes */
	ibt_status = ibt_alloc_qp(clientp->ic_ci_handle, IBT_UD_RQP,
	    &qp_attrs, &qp_ctx->isq_qp_sizes, &qp_ctx->isq_qpn,
	    &qp_ctx->isq_qp_handle);
	if (ibt_status != IBT_SUCCESS) {
		kmem_free(qp_ctx, sizeof (ibmf_alt_qp_t));
		(void) sprintf(errmsg, "failed to alloc qp, status = %d",
		    ibt_status);
		error = B_TRUE;
		status = IBMF_NO_RESOURCES;
		goto bail;
	}

	qp_modify_attr.qp_trans = IBT_UD_SRV;
	qp_modify_attr.qp_flags = IBT_CEP_NO_FLAGS;
	qp_modify_attr.qp_transport.ud.ud_qkey = q_key;
	qp_modify_attr.qp_transport.ud.ud_sq_psn = 0;
	qp_modify_attr.qp_transport.ud.ud_pkey_ix = pkey_ix;
	qp_modify_attr.qp_transport.ud.ud_port =
	    clientp->ic_client_info.port_num;

	/* Set up the client handle in the QP context */
	qp_ctx->isq_client_hdl = clientp;

	/* call the IB transport to initialize the QP */
	ibt_status = ibt_initialize_qp(qp_ctx->isq_qp_handle, &qp_modify_attr);
	if (ibt_status != IBT_SUCCESS) {
		(void) ibt_free_qp(qp_ctx->isq_qp_handle);
		kmem_free(qp_ctx, sizeof (ibmf_alt_qp_t));
		(void) sprintf(errmsg, "failed to initialize qp, status = %d",
		    ibt_status);
		error = B_TRUE;
		status = IBMF_NO_RESOURCES;
		goto bail;
	}

	/* Set up the WQE caches */
	status = ibmf_i_init_altqp_wqes(qp_ctx);
	if (status != IBMF_SUCCESS) {
		(void) ibt_free_qp(qp_ctx->isq_qp_handle);
		kmem_free(qp_ctx, sizeof (ibmf_alt_qp_t));
		(void) sprintf(errmsg, "failed to init wqe caches, status = %d",
		    status);
		error = B_TRUE;
		goto bail;
	}

	qp_ctx->isq_next = NULL;
	qp_ctx->isq_pkey = p_key;
	qp_ctx->isq_qkey = q_key;
	qp_ctx->isq_port_num = clientp->ic_client_info.port_num;
	mutex_init(&qp_ctx->isq_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&qp_ctx->isq_wqe_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&qp_ctx->isq_recv_cb_teardown_cv, NULL, CV_DRIVER, NULL);
	cv_init(&qp_ctx->isq_sqd_cv, NULL, CV_DRIVER, NULL);
	cv_init(&qp_ctx->isq_wqes_cv, NULL, CV_DRIVER, NULL);

	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*qp_ctx));

	/* add alt qp to the list in CI context */
	mutex_enter(&ibmf_cip->ci_mutex);
	if (ibmf_cip->ci_alt_qp_list == NULL) {
		ibmf_cip->ci_alt_qp_list = qp_ctx;
	} else {
		ibmf_alt_qp_t *qpp;

		qpp = ibmf_cip->ci_alt_qp_list;
		while (qpp->isq_next != NULL) {
			qpp = qpp->isq_next;
		}
		qpp->isq_next = qp_ctx;
	}
	mutex_exit(&ibmf_cip->ci_mutex);

	*ibmf_qp_handlep = (ibmf_qp_handle_t)qp_ctx;

	if (flags & IBMF_ALLOC_SLEEP)
		blocking = 1;
	else
		blocking = 0;

	/* post the max number of buffers to RQ */
	for (i = 0; i < ibmf_recv_wqes_per_port; i++) {
		status = ibmf_i_post_recv_buffer(ibmf_cip, clientp->ic_qp,
		    blocking, *ibmf_qp_handlep);
		if (status != IBMF_SUCCESS) {
			IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L3,
			    ibmf_i_alloc_qp, IBMF_TNF_TRACE, "",
			    "ibmf_i_alloc_qp(): %s, status = %d\n",
			    tnf_string, msg, "ibmf_i_post_recv_buffer() failed",
			    tnf_int, status, status);
		}
	}

	mutex_enter(&clientp->ic_kstat_mutex);
	IBMF_ADD32_KSTATS(clientp, alt_qps_alloced, 1);
	mutex_exit(&clientp->ic_kstat_mutex);

bail:
	if (error) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_alloc_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_alloc_qp(): %s\n", tnf_string, msg, errmsg);
	}

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_alloc_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_alloc_qp() exit, qp = %p\n",
	    tnf_opaque, qp_handlep, *ibmf_qp_handlep);
	return (status);
}

/*
 * ibmf_i_free_qp():
 *	Free an alternate QP context
 */
/* ARGSUSED */
int
ibmf_i_free_qp(ibmf_qp_handle_t ibmf_qp_handle, uint_t flags)
{
	ibmf_alt_qp_t		*qp_ctx = (ibmf_alt_qp_t *)ibmf_qp_handle;
	ibmf_client_t		*clientp = qp_ctx->isq_client_hdl;
	ibmf_ci_t		*ibmf_cip = qp_ctx->isq_client_hdl->ic_myci;
	ibmf_alt_qp_t		*qpp, *pqpp;
	ibt_status_t		ibt_status;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_free_qp_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_free_qp() enter, qp_hdl = %p, flags = %x\n",
	    tnf_opaque, qp_hdl, ibmf_qp_handle, tnf_uint, flags, flags);

	/* remove qp from the list in CI context */

	mutex_enter(&ibmf_cip->ci_mutex);
	qpp = ibmf_cip->ci_alt_qp_list;
	ASSERT(qpp != NULL);
	if (qpp == qp_ctx) {
		ibmf_cip->ci_alt_qp_list = qpp->isq_next;
	} else {
		while (qpp != NULL) {
			if (qpp == qp_ctx)
				break;
			pqpp = qpp;
			qpp = qpp->isq_next;
		}
		ASSERT(qpp != NULL);
		pqpp->isq_next = qpp->isq_next;
	}

	mutex_exit(&ibmf_cip->ci_mutex);

	/* flush the WQEs in the QP queues */
	ibt_status = ibt_flush_qp(qp_ctx->isq_qp_handle);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_free_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_free_qp(): %s, status = %d\n",
		    tnf_string, msg, "failed to close qp",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_free_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/* Call the MAD completion handler */
	ibmf_i_mad_completions(ibmf_cip->ci_alt_cq_handle, (void*)ibmf_cip);

	/* Wait here for all WQE owned by this QP to get freed */
	mutex_enter(&qpp->isq_mutex);
	while (qpp->isq_wqes_alloced != 0) {
		cv_wait(&qpp->isq_wqes_cv, &qpp->isq_mutex);
	}
	mutex_exit(&qpp->isq_mutex);

	cv_destroy(&qp_ctx->isq_recv_cb_teardown_cv);
	cv_destroy(&qp_ctx->isq_sqd_cv);
	cv_destroy(&qp_ctx->isq_wqes_cv);

	/* call the IB transport to free the QP */
	ibt_status = ibt_free_qp(qp_ctx->isq_qp_handle);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_free_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_free_qp(): %s, status = %d\n",
		    tnf_string, msg, "failed to free qp",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_free_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/* Clean up the WQE caches */
	ibmf_i_fini_altqp_wqes(qp_ctx);
	mutex_destroy(&qp_ctx->isq_wqe_mutex);
	mutex_destroy(&qp_ctx->isq_mutex);

	mutex_enter(&clientp->ic_kstat_mutex);
	IBMF_SUB32_KSTATS(clientp, alt_qps_alloced, 1);
	mutex_exit(&clientp->ic_kstat_mutex);

	kmem_free(qp_ctx, sizeof (ibmf_alt_qp_t));

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_free_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_free_qp() exit\n");

	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_query_qp():
 *	Query an alternate QP context
 */
/* ARGSUSED */
int
ibmf_i_query_qp(ibmf_qp_handle_t ibmf_qp_handle, uint_t flags,
    uint_t *qp_nump, ib_pkey_t *p_keyp, ib_qkey_t *q_keyp, uint8_t *portnump)
{
	ibt_qp_query_attr_t	qp_query;
	ibmf_alt_qp_t		*qp_ctx = (ibmf_alt_qp_t *)ibmf_qp_handle;
	uint16_t		pkey_ix;
	ibt_status_t		ibt_status;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_free_qp_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_free_qp() enter, qp_hdl = %p, flags = %x\n",
	    tnf_opaque, qp_hdl, ibmf_qp_handle, tnf_uint, flags, flags);

	ibt_status = ibt_query_qp(qp_ctx->isq_qp_handle, &qp_query);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_query_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_query_qp(): %s, status = %d\n",
		    tnf_string, msg, "failed to query qp",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_query_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_query_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/* move the desired attributes into the locations provided */
	*qp_nump = qp_query.qp_qpn;
	*q_keyp = qp_query.qp_info.qp_transport.ud.ud_qkey;
	*portnump = qp_query.qp_info.qp_transport.ud.ud_port;

	pkey_ix = qp_query.qp_info.qp_transport.ud.ud_pkey_ix;

	/* get the pkey based on the pkey_ix */
	ibt_status = ibt_index2pkey(qp_ctx->isq_client_hdl->ic_ci_handle,
	    *portnump, pkey_ix, p_keyp);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_3(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_query_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_query_qp(): %s, pkey_ix = %d, status = %d\n",
		    tnf_string, msg, "failed to get pkey from index",
		    tnf_uint, pkey_ix, pkey_ix,
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_query_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_query_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	IBMF_TRACE_4(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_query_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_query_qp() exit, qp_num = 0x%x, "
	    "pkey = 0x%x, qkey = 0x%x, portnum = %d\n",
	    tnf_uint, qp_num, *qp_nump, tnf_uint, pkey, *p_keyp,
	    tnf_uint, qkey, *q_keyp, tnf_uint, portnum, *portnump);

	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_modify_qp():
 *	Modify an alternate QP context
 */
/* ARGSUSED */
int
ibmf_i_modify_qp(ibmf_qp_handle_t ibmf_qp_handle, ib_pkey_t p_key,
    ib_qkey_t q_key, uint_t flags)
{
	ibmf_alt_qp_t		*qp_ctx = (ibmf_alt_qp_t *)ibmf_qp_handle;
	ibmf_client_t		*clientp = qp_ctx->isq_client_hdl;
	ibmf_ci_t		*ibmf_cip = clientp->ic_myci;
	ibmf_alt_qp_t		*qpp;
	ibt_qp_info_t		qp_mod;
	ibt_cep_modify_flags_t	qp_mod_flags;
	ibt_queue_sizes_t	actual_sz;
	uint16_t		pkey_ix;
	ibt_status_t		ibt_status;

	IBMF_TRACE_4(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_modify_qp_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_modify_qp() enter, qp_hdl = %p, flags = %x, pkey = 0x%x, "
	    "qkey = 0x%x\n", tnf_opaque, qp_hdl, ibmf_qp_handle,
	    tnf_uint, flags, flags, tnf_uint, p_key, p_key,
	    tnf_uint, q_key, q_key);

	/*
	 * get the pkey index associated with this pkey if present in table
	 */
	if (ibmf_i_get_pkeyix(clientp->ic_ci_handle, p_key,
	    clientp->ic_client_info.port_num, &pkey_ix) != IBMF_SUCCESS) {
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_modify_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_modify_qp(): %s, pkey = %x\n",
		    tnf_string, msg, "pkey not in table",
		    tnf_uint, pkey, p_key);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_modify_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_modify_qp() exit\n");
		return (IBMF_FAILURE);
	}

	/* Find the QP context in the CI QP context list */
	mutex_enter(&ibmf_cip->ci_mutex);
	qpp = ibmf_cip->ci_alt_qp_list;
	while (qpp != NULL) {
		if (qpp == qp_ctx) {
			break;
		}
		qpp = qpp->isq_next;
	}

	if (qpp == NULL) {
		mutex_exit(&ibmf_cip->ci_mutex);

		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_modify_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_modify_qp(): %s\n",
		    tnf_string, msg, "QP not in altqp list");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_modify_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_modify_qp() exit\n");
		return (IBMF_BAD_QP_HANDLE);

	} else {

		mutex_enter(&qp_ctx->isq_mutex);
	}

	mutex_exit(&ibmf_cip->ci_mutex);

	/*
	 * Transition the QP to SQD state
	 */
	bzero(&qp_mod, sizeof (ibt_qp_info_t));
	qp_mod.qp_trans = IBT_UD_SRV;
	qp_mod.qp_state = IBT_STATE_SQD;
	qp_mod_flags = IBT_CEP_SET_STATE | IBT_CEP_SET_SQD_EVENT;
	ibt_status = ibt_modify_qp(qp_ctx->isq_qp_handle, qp_mod_flags,
	    &qp_mod, &actual_sz);
	if (ibt_status != IBT_SUCCESS) {
		mutex_exit(&qp_ctx->isq_mutex);
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_modify_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_modify_qp(): %s, qp_hdl = %p\n",
		    tnf_string, msg, "QP transition RTS to SQD failed",
		    tnf_opaque, qp_handle, qp_ctx->isq_qp_handle);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_modify_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_modify_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	/*
	 * Wait for an event indicating that the QP is in SQD state
	 */
	cv_wait(&qp_ctx->isq_sqd_cv, &qp_ctx->isq_mutex);

	/* Setup QP modification information for transition to RTS state */
	bzero(&qp_mod, sizeof (ibt_qp_info_t));
	qp_mod.qp_trans = IBT_UD_SRV;
	qp_mod.qp_state = IBT_STATE_RTS;
	qp_mod.qp_current_state = IBT_STATE_SQD;
	qp_mod.qp_transport.ud.ud_pkey_ix = pkey_ix;
	qp_mod.qp_transport.ud.ud_qkey = q_key;
	qp_mod_flags = IBT_CEP_SET_STATE | IBT_CEP_SET_PKEY_IX |
	    IBT_CEP_SET_QKEY;

	/*
	 * transition the QP back to RTS state to allow
	 * modification of the pkey and qkey
	 */

	ibt_status = ibt_modify_qp(qp_ctx->isq_qp_handle, qp_mod_flags,
	    &qp_mod, &actual_sz);
	if (ibt_status != IBT_SUCCESS) {
		mutex_exit(&qp_ctx->isq_mutex);
		IBMF_TRACE_3(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_modify_qp_err, IBMF_TNF_TRACE, "",
		    "ibmf_i_modify_qp(): %s, qp_hdl = %p, status = %d\n",
		    tnf_string, msg, "QP transition SQD to RTS failed",
		    tnf_opaque, qp_handle, qp_ctx->isq_qp_handle,
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_modify_qp_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_modify_qp() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	qp_ctx->isq_pkey = p_key;
	qp_ctx->isq_qkey = q_key;
	mutex_exit(&qp_ctx->isq_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_modify_qp_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_modify_qp() exit\n");
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_post_recv_buffer():
 *	Post a WQE to the RQ of the specified QP
 */
int
ibmf_i_post_recv_buffer(ibmf_ci_t *cip, ibmf_qp_t *qpp, boolean_t block,
    ibmf_qp_handle_t ibmf_qp_handle)
{
	int			ret;
	ibt_wr_ds_t		*sgl;
	ibt_status_t		status;
	ibmf_recv_wqe_t		*recv_wqep;
	ibt_qp_hdl_t		ibt_qp_handle;
	struct kmem_cache	*kmem_cachep;
	ibmf_alt_qp_t		*altqp;

	IBMF_TRACE_4(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_post_recv_buffer_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_post_recv_buffer() enter, cip = %p, qpp = %p, "
	    "qp_hdl = %p, block = %d\n", tnf_opaque, cip, cip,
	    tnf_opaque, qpp, qpp, tnf_opaque, qp_hdl, ibmf_qp_handle,
	    tnf_uint, block, block);

	/*
	 * if we haven't hit the max wqes per qp, attempt to allocate a recv
	 * wqe and post it to the recv queue.
	 * It is possible for more than one thread to get through this
	 * check below and post wqes that could push us above the
	 * ibmf_recv_wqes_posted_per_qp. We catch that case when the recv
	 * completion is signaled.
	 */
	ASSERT(MUTEX_NOT_HELD(&cip->ci_mutex));

	/* Get the WQE kmem cache pointer based on the QP type */
	if (ibmf_qp_handle == IBMF_QP_HANDLE_DEFAULT)
		kmem_cachep = cip->ci_recv_wqes_cache;
	else {
		altqp = (ibmf_alt_qp_t *)ibmf_qp_handle;
		kmem_cachep = altqp->isq_recv_wqes_cache;
	}

	/* allocate a receive WQE from the receive WQE kmem cache */
	recv_wqep = kmem_cache_alloc(kmem_cachep,
	    (block == B_TRUE ? KM_SLEEP : KM_NOSLEEP));
	if (recv_wqep == NULL) {
		/*
		 * Attempt to extend the cache and then retry the
		 * kmem_cache_alloc()
		 */
		if (ibmf_i_extend_wqe_cache(cip, ibmf_qp_handle, block) ==
		    IBMF_NO_RESOURCES) {
			mutex_enter(&cip->ci_mutex);
			IBMF_ADD32_PORT_KSTATS(cip, rwqe_allocs_failed, 1);
			mutex_exit(&cip->ci_mutex);
			IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_post_recv_buffer_err, IBMF_TNF_ERROR, "",
			    "ibmf_i_post_recv_buffer(): %s, status = %d\n",
			    tnf_string, msg, "alloc recv_wqe failed",
			    tnf_int, ibmf_status, IBMF_NO_RESOURCES);
			IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_post_recv_buffer_end, IBMF_TNF_TRACE, "",
			    "ibmf_i_post_recv_buffer() exit\n");
			return (IBMF_NO_RESOURCES);
		} else {
			recv_wqep = kmem_cache_alloc(kmem_cachep,
			    (block == B_TRUE ? KM_SLEEP : KM_NOSLEEP));
			if (recv_wqep == NULL) {
				/* Allocation failed again. Give up here. */
				mutex_enter(&cip->ci_mutex);
				IBMF_ADD32_PORT_KSTATS(cip, rwqe_allocs_failed,
				    1);
				mutex_exit(&cip->ci_mutex);
				IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
				    ibmf_i_post_recv_buffer_err,
				    IBMF_TNF_ERROR, "",
				    "ibmf_i_post_recv_buffer(): %s, "
				    "status = %d\n",
				    tnf_string, msg, "alloc recv_wqe failed",
				    tnf_int, ibmf_status, IBMF_NO_RESOURCES);
				IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
				    ibmf_i_post_recv_buffer_end,
				    IBMF_TNF_TRACE, "",
				    "ibmf_i_post_recv_buffer() exit\n");
				return (IBMF_NO_RESOURCES);
			}
		}
	}

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*recv_wqep))

	/*
	 * if the qp handle provided in ibmf_send_pkt() or
	 * ibmf_setup_recv_cb() is not the default qp handle
	 * for this client, then the wqe must be queued on this qp,
	 * else use the default qp handle set up during ibmf_register()
	 */
	if (ibmf_qp_handle == IBMF_QP_HANDLE_DEFAULT) {
		ibt_qp_handle = qpp->iq_qp_handle;
	} else {
		ibt_qp_handle =
		    ((ibmf_alt_qp_t *)ibmf_qp_handle)->isq_qp_handle;
	}

	/* allocate memory for the scatter-gather list */
	sgl = kmem_zalloc(IBMF_MAX_RQ_WR_SGL_ELEMENTS * sizeof (ibt_wr_ds_t),
	    (block == B_TRUE) ? KM_SLEEP : KM_NOSLEEP);
	if (sgl == NULL) {
		kmem_cache_free(kmem_cachep, recv_wqep);
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_post_recv_buffer_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_post_recv_buffer(): %s\n",
		    tnf_string, msg, "failed to kmem_zalloc qp ctx");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_post_recv_buffer_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_post_recv_buffer() exit\n");
		return (IBMF_NO_RESOURCES);
	}

	/* initialize it */
	ibmf_i_init_recv_wqe(qpp, sgl, recv_wqep, ibt_qp_handle,
	    ibmf_qp_handle);

	_NOTE(NOW_VISIBLE_TO_OTHER_THREADS(*recv_wqep))

	/* and post it */
	status = ibt_post_recv(recv_wqep->recv_qp_handle, &recv_wqep->recv_wr,
	    1, NULL);

	ret = ibmf_i_ibt_to_ibmf_status(status);
	if (ret != IBMF_SUCCESS) {
		kmem_free(sgl, IBMF_MAX_RQ_WR_SGL_ELEMENTS *
		    sizeof (ibt_wr_ds_t));
		kmem_cache_free(kmem_cachep, recv_wqep);
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_post_recv_buffer_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_post_recv_buffer(): %s, status = %d\n",
		    tnf_string, msg, "ibt_post_recv failed",
		    tnf_uint, ibt_status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_post_recv_buffer_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_post_recv_buffer() exit\n");
		return (ret);
	}

	mutex_enter(&cip->ci_mutex);
	IBMF_ADD32_PORT_KSTATS(cip, recv_wqes_alloced, 1);
	mutex_exit(&cip->ci_mutex);
	if (ibmf_qp_handle == IBMF_QP_HANDLE_DEFAULT) {
		mutex_enter(&qpp->iq_mutex);
		qpp->iq_rwqes_posted++;
		mutex_exit(&qpp->iq_mutex);
		mutex_enter(&cip->ci_mutex);
		cip->ci_wqes_alloced++;
		mutex_exit(&cip->ci_mutex);
	} else {
		mutex_enter(&altqp->isq_mutex);
		altqp->isq_wqes_alloced++;
		altqp->isq_rwqes_posted++;
		mutex_exit(&altqp->isq_mutex);
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_post_recv_buffer_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_post_recv_buffer() exit\n");

	return (ret);
}

/*
 * ibmf_i_mgt_class_to_hdr_sz_off():
 *	Determine class header offser and size for management classes
 */
void
ibmf_i_mgt_class_to_hdr_sz_off(uint32_t mgt_class, uint32_t *szp,
    uint32_t *offp)
{
	uint32_t	hdr_sz = 0, hdr_off = 0;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_mgt_class_to_hdr_sz_off_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_mgt_class_to_hdr_sz_off(): mgt_class = 0x%x\n",
	    tnf_uint, mgt_class, mgt_class);

	switch (mgt_class) {
	case MAD_MGMT_CLASS_SUBN_LID_ROUTED :
	case MAD_MGMT_CLASS_SUBN_DIRECT_ROUTE :
	case MAD_MGMT_CLASS_PERF :
	case MAD_MGMT_CLASS_BM :
	case MAD_MGMT_CLASS_DEV_MGT :
	case MAD_MGMT_CLASS_SNMP :
	case MAD_MGMT_CLASS_COMM_MGT:
		hdr_sz = IBMF_MAD_CL_HDR_SZ_1;
		hdr_off = IBMF_MAD_CL_HDR_OFF_1;
		break;
	case MAD_MGMT_CLASS_SUBN_ADM :
		hdr_sz = IBMF_MAD_CL_HDR_SZ_2;
		hdr_off = IBMF_MAD_CL_HDR_OFF_2;
		break;
	default:
		if (((mgt_class >= MAD_MGMT_CLASS_VENDOR_START) &&
		    (mgt_class <= MAD_MGMT_CLASS_VENDOR_END)) ||
		    ((mgt_class >= MAD_MGMT_CLASS_APPLICATION_START) &&
		    (mgt_class <= MAD_MGMT_CLASS_APPLICATION_END))) {
			hdr_sz = IBMF_MAD_CL_HDR_SZ_3;
			hdr_off = IBMF_MAD_CL_HDR_OFF_1;
		} else if ((mgt_class >= MAD_MGMT_CLASS_VENDOR2_START) &&
		    (mgt_class <= MAD_MGMT_CLASS_VENDOR2_END)) {
			hdr_sz = IBMF_MAD_CL_HDR_SZ_4;
			hdr_off = IBMF_MAD_CL_HDR_OFF_2;
		} else {
			IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_mgt_class_to_hdr_sz_off_start,
			    IBMF_TNF_TRACE, "",
			    "ibmf_i_mgt_class_to_hdr_sz_off():"
			    "got illegal management class = 0x%x\n",
			    tnf_uint, mgt_class, mgt_class);
		}
		break;
	}



	*szp = hdr_sz;
	*offp = hdr_off;

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_mgt_class_to_hdr_sz_off_end, IBMF_TNF_TRACE, "",
	    "ibmf_i_mgt_class_to_hdr_sz_off() exit,hdr_sz = %d, hdr_off = %d\n",
	    tnf_uint, hdr_sz, hdr_sz, tnf_uint, hdr_off, hdr_off);
}

/*
 * ibmf_i_lookup_client_by_mgmt_class():
 *	Lookup the client context based on the management class of
 *	the incoming packet
 */
int
ibmf_i_lookup_client_by_mgmt_class(ibmf_ci_t *ibmf_cip, int port_num,
    ibmf_client_type_t class, ibmf_client_t **clientpp)
{
	ibmf_client_t 		*clientp;
	ibmf_client_info_t	*client_infop;

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_lookup_client_by_mgmt_class_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_lookup_client_by_mgmt_class() enter, cip = %p, "
	    "port_num = %d, class = 0x%x\n", tnf_opaque, cip, ibmf_cip,
	    tnf_int, port, port_num, tnf_opaque, class, class);

	ASSERT(MUTEX_NOT_HELD(&ibmf_cip->ci_clients_mutex));

	mutex_enter(&ibmf_cip->ci_clients_mutex);

	clientp = ibmf_cip->ci_clients;

	/* walk client context list looking for class/portnum match */
	while (clientp != NULL) {
		client_infop = &clientp->ic_client_info;
		if (class == client_infop->client_class &&
		    port_num == client_infop->port_num) {
			/* found our match */
			break;
		}
		clientp = clientp->ic_next;
	}

	mutex_exit(&ibmf_cip->ci_clients_mutex);

	if (clientp != NULL) {
		*clientpp = clientp;
		IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_lookup_client_by_mgmt_class_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_lookup_client_by_mgmt_class() exit, clp = %p\n",
		    tnf_opaque, clientp, clientp);
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_lookup_client_by_mgmt_class_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_lookup_client_by_mgmt_class() failure exit\n");
		return (IBMF_FAILURE);
	}
}

/*
 * ibmf_i_get_pkeyix():
 *	Get the pkey index of the pkey in the pkey table of the specified
 *	port. Take into account the partition membership.
 */
int
ibmf_i_get_pkeyix(ibt_hca_hdl_t hca_handle, ib_pkey_t pkey, uint8_t port,
    ib_pkey_t *pkeyixp)
{
	ib_pkey_t		tpkey;
	ibt_status_t		ibt_status;

	IBMF_TRACE_3(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_pkeyix_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_get_pkeyix() enter, hcahdl = %p, "
	    "pkey = 0x%x, port = %d\n", tnf_opaque, hcahdl, hca_handle,
	    tnf_int, pkey, pkey, tnf_int, port, port);

	/*
	 * If the client specifies the FULL membership pkey and the
	 * pkey is not in the table, this function should fail.
	 */
	if (pkey & IBMF_PKEY_MEMBERSHIP_MASK) {
		ibt_status = ibt_pkey2index(hca_handle, port,
		    pkey, pkeyixp);
		if (ibt_status != IBT_SUCCESS) {
			IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
			    ibmf_i_get_pkeyix_err, IBMF_TNF_ERROR, "",
			    "ibmf_i_get_pkeyix() error status = %d\n",
			    tnf_uint, ibt_status, ibt_status);
			IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
			    ibmf_i_get_pkeyix_end, IBMF_TNF_TRACE, "",
			    "ibmf_i_get_pkeyix() exit\n");
			return (IBMF_TRANSPORT_FAILURE);
		}
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_pkeyix_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_get_pkeyix() exit\n");
		return (IBMF_SUCCESS);
	}

	/*
	 * Limited member pkey processing
	 * Check if this limited member pkey is in the pkey table
	 */
	ibt_status = ibt_pkey2index(hca_handle, port, pkey, pkeyixp);
	if (ibt_status == IBT_SUCCESS) {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_get_pkeyix_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_get_pkeyix() exit\n");
		return (IBMF_SUCCESS);
	}

	/*
	 * Could not find the limited member version of the pkey.
	 * Now check if the full member version of the pkey is in the
	 * pkey table. If not, fail the call.
	 */
	tpkey = pkey | IBMF_PKEY_MEMBERSHIP_MASK;
	ibt_status = ibt_pkey2index(hca_handle, port, tpkey, pkeyixp);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_get_pkeyix_err, IBMF_TNF_ERROR, "",
		    "ibmf_i_get_pkeyix() error status = %d\n",
		    tnf_uint, ibt_status, ibt_status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_get_pkeyix_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_get_pkeyix() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_get_pkeyix_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_get_pkeyix(): pkey_ix = %d\n",
	    tnf_int, pkeyix, *pkeyixp);
	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_pkey_ix_to_key():
 *	Figure out pkey from pkey index
 */
int
ibmf_i_pkey_ix_to_key(ibmf_ci_t *cip, uint_t port_num, uint_t pkey_ix,
    ib_pkey_t *pkeyp)
{
	ibt_status_t		ibt_status;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_pkey_ix_to_key_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_pkey_ix_to_key() enter\n");

	ibt_status = ibt_index2pkey(cip->ci_ci_handle, port_num, pkey_ix,
	    pkeyp);
	if (ibt_status != IBT_SUCCESS) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_i_pkey_ix_to_key, IBMF_TNF_TRACE, "",
		    "ibmf_i_pkey_ix_to_key(): ibt_index2pkey failed for "
		    " pkey index %d \n", tnf_uint, pkey_ix, pkey_ix);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_pkey_ix_to_key_end,
		    IBMF_TNF_TRACE, "", "ibmf_i_pkey_ix_to_key() exit\n");
		return (IBMF_TRANSPORT_FAILURE);
	}

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_pkey_ix_to_key_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_pkey_ix_to_key() exit\n");

	return (IBMF_SUCCESS);
}

/*
 * ibmf_i_ibt_to_ibmf_status():
 *	Map IBT return code to IBMF return code
 */
int
ibmf_i_ibt_to_ibmf_status(ibt_status_t ibt_status)
{
	int ibmf_status;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_ibt_to_ibmf_status_start,
	    IBMF_TNF_TRACE, "", "ibmf_i_ibt_to_ibmf_status() enter, "
	    "status = %d\n", tnf_uint, ibt_status, ibt_status);

	switch (ibt_status) {

	case IBT_SUCCESS:
		ibmf_status = IBMF_SUCCESS;
		break;

	case IBT_INSUFF_KERNEL_RESOURCE:
	case IBT_INSUFF_RESOURCE:
	case IBT_QP_FULL:
		ibmf_status = IBMF_NO_RESOURCES;
		break;

	case IBT_HCA_IN_USE:
	case IBT_QP_IN_USE:
	case IBT_CQ_BUSY:
	case IBT_PD_IN_USE:
	case IBT_MR_IN_USE:
		ibmf_status = IBMF_BUSY;
		break;

	default:
		ibmf_status = IBMF_FAILURE;
		break;
	}

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_i_ibt_to_ibmf_status_end,
	    IBMF_TNF_TRACE, "", "ibmf_i_ibt_to_ibmf_status() exit, "
	    "ibt_status = %d, ibmf_status = %d\n", tnf_uint, ibt_status,
	    ibt_status, tnf_int, ibmf_status, ibmf_status);

	return (ibmf_status);
}

/*
 * ibmf_i_ibt_wc_to_ibmf_status():
 *	Map work completion code to IBMF return code
 */
int
ibmf_i_ibt_wc_to_ibmf_status(ibt_wc_status_t ibt_wc_status)
{
	int ibmf_status;

	IBMF_TRACE_1(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_ibt_wc_to_ibmf_status_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_ibt_to_ibmf_status() enter, status = %d\n",
	    tnf_uint, ibt_wc_status, ibt_wc_status);

	switch (ibt_wc_status) {

	case IBT_WC_SUCCESS:
		ibmf_status = IBMF_SUCCESS;
		break;

	default:
		ibmf_status = IBMF_FAILURE;
		break;
	}

	IBMF_TRACE_2(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_ibt_wc_to_ibmf_status_end, IBMF_TNF_TRACE, "",
	    "ibmf_i_ibt_to_ibmf_status() exit, wc_status = %d, "
	    "ibmf_status = %d\n", tnf_uint, ibt_wc_status,
	    ibt_wc_status, tnf_int, ibmf_status, ibmf_status);

	return (ibmf_status);
}

/*
 * ibmf_i_is_ibmf_handle_valid():
 *	Validate the ibmf handle
 */
int
ibmf_i_is_ibmf_handle_valid(ibmf_handle_t ibmf_handle)
{
	ibmf_ci_t	*cip;
	ibmf_client_t	*clp, *clientp = (ibmf_client_t *)ibmf_handle;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_is_ibmf_handle_valid_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_is_ibmf_handle_valid() enter\n");

	mutex_enter(&ibmf_statep->ibmf_mutex);

	cip = ibmf_statep->ibmf_ci_list;

	/* iterate through all the channel interace contexts */
	while (cip != NULL) {

		mutex_enter(&cip->ci_clients_mutex);

		clp = cip->ci_clients;

		/* search all registration contexts for this ci */
		while (clp != NULL) {
			if (clp == clientp)
				break;
			clp = clp->ic_next;
		}

		mutex_exit(&cip->ci_clients_mutex);

		if (clp == clientp) {
			/* ci found */
			break;
		} else {
			/* ci not found, move onto next ci */
			cip = cip->ci_next;
		}
	}

	mutex_exit(&ibmf_statep->ibmf_mutex);

	if (cip != NULL) {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_is_ibmf_handle_valid_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_is_ibmf_handle_valid() exit\n");
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_is_ibmf_handle_valid_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_is_ibmf_handle_valid() failure exit\n");
		return (IBMF_FAILURE);
	}
}

/*
 * ibmf_i_is_qp_handle_valid():
 *	Validate the QP handle
 */
int
ibmf_i_is_qp_handle_valid(ibmf_handle_t ibmf_handle,
    ibmf_qp_handle_t ibmf_qp_handle)
{
	ibmf_client_t	*clientp = (ibmf_client_t *)ibmf_handle;
	ibmf_alt_qp_t	*alt_qp, *qpp = (ibmf_alt_qp_t *)ibmf_qp_handle;
	ibmf_ci_t	*cip = clientp->ic_myci;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_i_is_qp_handle_valid_start, IBMF_TNF_TRACE, "",
	    "ibmf_i_is_qp_handle_valid() enter\n");

	/* the default qp handle is always valid */
	if (ibmf_qp_handle == IBMF_QP_HANDLE_DEFAULT)
		return (IBMF_SUCCESS);

	mutex_enter(&cip->ci_mutex);

	alt_qp = cip->ci_alt_qp_list;

	while (alt_qp != NULL) {
		if (alt_qp == qpp) {
			/* qp handle found */
			break;
		} else {
			/* qp handle not found, get next qp on list */
			alt_qp = alt_qp->isq_next;
		}
	}

	mutex_exit(&cip->ci_mutex);

	if (alt_qp != NULL) {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_is_qp_handle_valid_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_is_qp_handle_valid() exit\n");
		return (IBMF_SUCCESS);
	} else {
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_i_is_qp_handle_valid_end, IBMF_TNF_TRACE, "",
		    "ibmf_i_is_qp_handle_valid() failure exit\n");
		return (IBMF_FAILURE);
	}
}

void
ibmf_dprintf(int l, const char *fmt, ...)
{
	va_list ap;

	if ((l) > ibmf_trace_level) {

		return;
	}

	va_start(ap, fmt);
	(void) vprintf(fmt, ap);
	va_end(ap);
}

/*
 * ibmf_setup_term_ctx():
 * Sets up a message context that is the duplicate of the one
 * passed in the regmsgimplp argument. The duplicate message context
 * is not visible to the client. It is managed internally by ibmf
 * to process the RMPP receiver termination flow logic for the
 * transaction while the client is notified of the completion of the
 * same transaction (i.e. all the solicited data has been received).
 */
int
ibmf_setup_term_ctx(ibmf_client_t *clientp, ibmf_msg_impl_t *regmsgimplp)
{
	ibmf_msg_impl_t	*msgimplp;
	size_t		offset;
	uint32_t	cl_hdr_sz, cl_hdr_off;
	int		status;

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
	    ibmf_setup_term_ctx_start, IBMF_TNF_TRACE, "",
	    "ibmf_setup_term_ctx() enter\n");

	/*
	 * Allocate the termination message context
	 */
	msgimplp = (ibmf_msg_impl_t *)kmem_zalloc(sizeof (ibmf_msg_impl_t),
	    KM_NOSLEEP);
	if (msgimplp == NULL) {
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_setup_term_ctx_error, IBMF_TNF_ERROR, "",
		    "ibmf_setup_term_ctx(): %s\n", tnf_string, msg,
		    "message mem allocation failure");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_setup_term_ctx_end, IBMF_TNF_TRACE, "",
		    "ibmf_setup_term_ctx() exit\n");
		return (IBMF_NO_RESOURCES);
	}

	_NOTE(NOW_INVISIBLE_TO_OTHER_THREADS(*msgimplp))

	/* Copy the message context to the termination message structure */
	*msgimplp = *regmsgimplp;

	/* Initialize the message mutex */
	mutex_init(&msgimplp->im_mutex, NULL, MUTEX_DRIVER, NULL);

	/*
	 * Allocate enough memory for the MAD header only.
	 */
	msgimplp->im_msgbufs_recv.im_bufs_mad_hdr =
	    (ib_mad_hdr_t *)kmem_zalloc(IBMF_MAD_SIZE, KM_NOSLEEP);
	if (msgimplp->im_msgbufs_recv.im_bufs_mad_hdr == NULL) {
		kmem_free(msgimplp, sizeof (ibmf_msg_impl_t));
		IBMF_TRACE_1(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_setup_term_ctx_error, IBMF_TNF_ERROR, "",
		    "ibmf_setup_term_ctx(): %s\n", tnf_string, msg,
		    "recv buf mem allocation failure");
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_setup_term_ctx_end, IBMF_TNF_TRACE, "",
		    "ibmf_setup_term_ctx() exit\n");
		return (IBMF_NO_RESOURCES);
	}

	/* Copy over just the MAD header contents */
	bcopy((const void *)regmsgimplp->im_msgbufs_recv.im_bufs_mad_hdr,
	    (void *)msgimplp->im_msgbufs_recv.im_bufs_mad_hdr,
	    sizeof (ib_mad_hdr_t));

	offset = sizeof (ib_mad_hdr_t);
	ibmf_i_mgt_class_to_hdr_sz_off(
	    regmsgimplp->im_msgbufs_recv.im_bufs_mad_hdr->MgmtClass,
	    &cl_hdr_sz, &cl_hdr_off);
	offset += cl_hdr_off;

	/*
	 * Copy the management class header
	 */
	msgimplp->im_msgbufs_recv.im_bufs_cl_hdr =
	    (uchar_t *)msgimplp->im_msgbufs_recv.im_bufs_mad_hdr + offset;
	msgimplp->im_msgbufs_recv.im_bufs_cl_hdr_len =
	    regmsgimplp->im_msgbufs_recv.im_bufs_cl_hdr_len;
	bcopy((void *)regmsgimplp->im_msgbufs_recv.im_bufs_cl_hdr,
	    (void *)msgimplp->im_msgbufs_recv.im_bufs_cl_hdr,
	    regmsgimplp->im_msgbufs_recv.im_bufs_cl_hdr_len);

	/*
	 * Clear the termination message timers copied from the regular message
	 * since ibmf_i_set_timer() expects them to be cleared.
	 */
	msgimplp->im_rp_timeout_id = 0;
	msgimplp->im_tr_timeout_id = 0;

	/* Mark this message as being in a receiver RMPP mode */
	msgimplp->im_flags |= IBMF_MSG_FLAGS_RECV_RMPP;

	/* Mark this message as being a "termination flow" message */
	msgimplp->im_flags |= IBMF_MSG_FLAGS_TERMINATION;

	/*
	 * Clear the IBMF_MSG_FLAGS_SET_TERMINATION copied over from the regular
	 * message.
	 */
	msgimplp->im_flags &= ~IBMF_MSG_FLAGS_SET_TERMINATION;

	/*
	 * Clear the trans_state RECV_DONE and DONE flags so that the
	 * protocol continues with the termination message context.
	 */
	msgimplp->im_trans_state_flags &= ~IBMF_TRANS_STATE_FLAG_RECV_DONE;
	msgimplp->im_trans_state_flags &= ~IBMF_TRANS_STATE_FLAG_DONE;

	/* Clear out references to the old UD dest handles */
	msgimplp->im_ibmf_ud_dest = NULL;
	msgimplp->im_ud_dest = NULL;

	/*
	 * Request new UD dest resources for the termination phase.
	 * The old UD dest resources are freed when the IBMF client
	 * calls ibmf_free_msg(), so they cannot be relied on to exist
	 * when the RMPP termination loop completes.
	 */
	status = ibmf_i_alloc_ud_dest(clientp, msgimplp, &msgimplp->im_ud_dest,
	    B_FALSE);
	if (status != IBMF_SUCCESS) {
		kmem_free(msgimplp, sizeof (ibmf_msg_impl_t));
		IBMF_TRACE_2(IBMF_TNF_NODEBUG, DPRINT_L1,
		    ibmf_setup_term_ctx_err, IBMF_TNF_ERROR, "",
		    "ibmf_setup_term_ctx(): %s, status = %d\n",
		    tnf_string, msg, "UD destination resource allocation"
		    " failed", tnf_int, ibmf_status, status);
		IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4,
		    ibmf_setup_term_ctx_end, IBMF_TNF_TRACE, "",
		    "ibmf_setup_term_ctx() exit\n");
		return (status);
	}

	/*
	 * Add the message to the termination client list by virtue of
	 * having the IBMF_MSG_FLAGS_TERMINATION "im_flags" flag set.
	 */
	ibmf_i_client_add_msg(clientp, msgimplp);

	/*
	 * Increase the "allocted messages" count so that the client
	 * does not unregister before this message has been freed.
	 * This is necessary because we want the client context to
	 * be around when the receive timeout expires for this termination
	 * loop, otherwise the code will access freed memory and crash.
	 */
	mutex_enter(&clientp->ic_mutex);
	clientp->ic_msgs_alloced++;
	mutex_exit(&clientp->ic_mutex);

	mutex_enter(&msgimplp->im_mutex);
	/* Set the response timer for the termination message. */
	ibmf_i_set_timer(ibmf_i_recv_timeout, msgimplp, IBMF_RESP_TIMER);
	mutex_exit(&msgimplp->im_mutex);

	IBMF_TRACE_0(IBMF_TNF_DEBUG, DPRINT_L4, ibmf_setup_term_ctx_end,
	    IBMF_TNF_TRACE, "", "ibmf_setup_term_ctx() exit\n");

	return (IBMF_SUCCESS);
}