/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/byteorder.h>
#include <sys/sdt.h>

#include <sys/ib/clients/iser/iser.h>

/*
 * iser_xfer.c
 */

int
iser_xfer_hello_msg(iser_chan_t *chan)
{
	iser_hca_t		*hca;
	iser_wr_t		*iser_wr;
	iser_msg_t		*msg;
	ibt_send_wr_t		wr;
	iser_hello_hdr_t	*hdr;
	int			status;

	ASSERT(chan != NULL);

	hca = (iser_hca_t *)chan->ic_hca;
	if (hca == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_hello_msg: no hca handle found");
		return (ISER_STATUS_FAIL);
	}

	msg = iser_msg_get(hca, 1, NULL);

	if (msg == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_hello_msg: iser message cache "
		    "alloc failed");
		return (ISER_STATUS_FAIL);
	}

	/* Send iSER Hello Message to declare iSER parameters to the target */
	hdr = (iser_hello_hdr_t *)(uintptr_t)msg->msg_ds.ds_va;

	hdr->opcode	= ISER_OPCODE_HELLO_MSG;
	hdr->rsvd1	= 0;
	hdr->maxver 	= 1;
	hdr->minver 	= 1;
	hdr->iser_ird 	= htons(ISER_IB_DEFAULT_IRD);
	hdr->rsvd2[0] 	= 0;
	hdr->rsvd2[1] 	= 0;

	/* Allocate an iSER WR handle and tuck this msg into it */
	iser_wr = iser_wr_get();
	if (iser_wr == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_hello_msg: unable to allocate "
		    "iser wr handle");
		iser_msg_free(msg);
		return (ISER_STATUS_FAIL);
	}
	iser_wr->iw_msg = msg;
	iser_wr->iw_type = ISER_WR_SEND;

	/* Use the address of our generic iser_wr handle as our WRID */
	wr.wr_id	= (ibt_wrid_t)(uintptr_t)iser_wr;

	/* Populate the rest of the work request */
	wr.wr_trans	= IBT_RC_SRV;
	wr.wr_opcode	= IBT_WRC_SEND;
	wr.wr_nds	= 1;
	wr.wr_sgl	= &msg->msg_ds;

	/*
	 * Avoid race condition by incrementing this channel's
	 * SQ posted count prior to calling ibt_post_send
	 */
	mutex_enter(&chan->ic_sq_post_lock);
	chan->ic_sq_post_count++;
	if (chan->ic_sq_post_count > chan->ic_sq_max_post_count)
		chan->ic_sq_max_post_count = chan->ic_sq_post_count;
	mutex_exit(&chan->ic_sq_post_lock);

	status = ibt_post_send(chan->ic_chanhdl, &wr, 1, NULL);
	if (status != IBT_SUCCESS) {
		ISER_LOG(CE_NOTE, "iser_xfer_hello_msg: ibt_post_send "
		    "failure (%d)", status);
		mutex_enter(&chan->ic_sq_post_lock);
		chan->ic_sq_post_count--;
		mutex_exit(&chan->ic_sq_post_lock);
		iser_msg_free(msg);
		iser_wr_free(iser_wr);
		return (ISER_STATUS_FAIL);
	}

	ISER_LOG(CE_NOTE, "Posting iSER Hello message: chan (0x%p): "
	    "IP [%x to %x]", (void *)chan, chan->ic_localip.un.ip4addr,
	    chan->ic_remoteip.un.ip4addr);

	return (ISER_STATUS_SUCCESS);
}

int
iser_xfer_helloreply_msg(iser_chan_t *chan)
{
	iser_hca_t		*hca;
	iser_wr_t		*iser_wr;
	ibt_send_wr_t   	wr;
	iser_msg_t		*msg;
	iser_helloreply_hdr_t	*hdr;
	int			status;

	ASSERT(chan != NULL);

	hca = (iser_hca_t *)chan->ic_hca;
	if (hca == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_helloreply_msg: no hca handle "
		    "found");
		return (ISER_STATUS_FAIL);
	}

	msg = iser_msg_get(hca, 1, NULL);

	if (msg == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_helloreply_msg: iser message "
		    "cache alloc failed");
		return (ISER_STATUS_FAIL);
	}

	/* Use the iSER Hello Reply Message */
	hdr = (iser_helloreply_hdr_t *)(uintptr_t)msg->msg_ds.ds_va;

	hdr->opcode	= ISER_OPCODE_HELLOREPLY_MSG;
	hdr->rsvd1	= 0;
	hdr->flag	= 0;
	hdr->maxver	= 1;
	hdr->curver	= 1;
	hdr->iser_ord	= htons(ISER_IB_DEFAULT_ORD);
	hdr->rsvd2[0]	= 0;
	hdr->rsvd2[1]	= 0;

	/* Allocate an iSER WR handle and tuck this msg into it */
	iser_wr = iser_wr_get();
	if (iser_wr == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_helloreply_msg: unable to "
		    "allocate iser wr handle");
		iser_msg_free(msg);
		return (ISER_STATUS_FAIL);
	}
	iser_wr->iw_msg = msg;
	iser_wr->iw_type = ISER_WR_SEND;

	/* Use the address of our generic iser_wr handle as our WRID */
	wr.wr_id	= (ibt_wrid_t)(uintptr_t)iser_wr;

	/* Populate the rest of the work request */
	wr.wr_trans	= IBT_RC_SRV;
	wr.wr_opcode	= IBT_WRC_SEND;
	wr.wr_nds	= 1;
	wr.wr_sgl	= &msg->msg_ds;

	mutex_enter(&chan->ic_sq_post_lock);
	chan->ic_sq_post_count++;
	if (chan->ic_sq_post_count > chan->ic_sq_max_post_count)
		chan->ic_sq_max_post_count = chan->ic_sq_post_count;

	mutex_exit(&chan->ic_sq_post_lock);

	status = ibt_post_send(chan->ic_chanhdl, &wr, 1, NULL);
	if (status != IBT_SUCCESS) {
		ISER_LOG(CE_NOTE, "iser_xfer_helloreply_msg: ibt_post_send "
		    "failure (%d)", status);
		mutex_enter(&chan->ic_sq_post_lock);
		chan->ic_sq_post_count--;
		mutex_exit(&chan->ic_sq_post_lock);
		iser_msg_free(msg);
		iser_wr_free(iser_wr);
		return (ISER_STATUS_FAIL);
	}
	ISER_LOG(CE_NOTE, "Posting iSER HelloReply message: chan (0x%p): "
	    "IP [%x to %x]", (void *)chan, chan->ic_localip.un.ip4addr,
	    chan->ic_remoteip.un.ip4addr);

	return (ISER_STATUS_SUCCESS);
}

/*
 * iser_xfer_ctrlpdu
 *
 * This is iSER's implementation of the 'Send_control' operational primitive.
 * This iSER layer uses the Send Message type of RCaP to transfer the iSCSI
 * Control-type PDU. A special case is that the transfer of SCSI Data-out PDUs
 * carrying unsolicited data are also treated as iSCSI Control-Type PDUs. The
 * message payload contains an iSER header followed by the iSCSI Control-type
 * the iSCSI Control-type PDU.
 * This function is invoked by an initiator iSCSI layer requesting the transfer
 * of a iSCSI command PDU or a target iSCSI layer requesting the transfer of a
 * iSCSI response PDU.
 */
int
iser_xfer_ctrlpdu(iser_chan_t *chan, idm_pdu_t *pdu)
{
	iser_hca_t	*hca;
	iser_ctrl_hdr_t	*hdr;
	iser_msg_t	*msg;
	iser_wr_t	*iser_wr;
	ibt_send_wr_t   wr;
	int		status;
	iser_mr_t	*mr;
	iscsi_data_hdr_t	*bhs;
	idm_conn_t	*ic;
	idm_task_t	*idt = NULL;
	idm_buf_t	*buf;

	ASSERT(chan != NULL);

	mutex_enter(&chan->ic_conn->ic_lock);
	/* Bail out if the connection is closed */
	if ((chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSING) ||
	    (chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSED)) {
		mutex_exit(&chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	ic = chan->ic_conn->ic_idmc;

	/* Pull the BHS out of the PDU handle */
	bhs = (iscsi_data_hdr_t *)pdu->isp_hdr;

	/*
	 * All SCSI command PDU (except SCSI Read and SCSI Write) and the SCSI
	 * Response PDU are sent to the remote end using the SendSE Message.
	 *
	 * The StatSN may need to be sent (and possibly advanced) at this time
	 * for some PDUs, identified by the IDM_PDU_SET_STATSN flag.
	 */
	if (pdu->isp_flags & IDM_PDU_SET_STATSN) {
		(ic->ic_conn_ops.icb_update_statsn)(NULL, pdu);
	}
	/*
	 * Setup a Send Message for carrying the iSCSI control-type PDU
	 * preceeded by an iSER header.
	 */
	hca = (iser_hca_t *)chan->ic_hca;
	if (hca == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_ctrlpdu: no hca handle found");
		mutex_exit(&chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	msg = iser_msg_get(hca, 1, NULL);
	if (msg == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_ctrlpdu: iser message cache "
		    "alloc failed");
		mutex_exit(&chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	hdr = (iser_ctrl_hdr_t *)(uintptr_t)msg->msg_ds.ds_va;

	/*
	 * Initialize header assuming no transfers
	 */
	bzero(hdr, sizeof (*hdr));
	hdr->opcode	= ISER_OPCODE_CTRL_TYPE_PDU;

	/*
	 * On the initiator side, the task buffers will be used to identify
	 * if there are any buffers to be advertised
	 */
	if ((ic->ic_conn_type == CONN_TYPE_INI) &&
	    ((bhs->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_SCSI_CMD) &&
	    ((idt = idm_task_find(ic, bhs->itt, bhs->ttt)) != NULL)) {

		if (!list_is_empty(&idt->idt_inbufv)) {
			buf = idm_buf_find(&idt->idt_inbufv, 0);
			ASSERT(buf != NULL);

			mr = (iser_mr_t *)buf->idb_reg_private;
			ASSERT(mr != NULL);

			hdr->rsv_flag = 1;
			hdr->rstag = htonl(mr->is_mrrkey);
			BE_OUT64(&hdr->rva, mr->is_mrva);
		}

		if (!list_is_empty(&idt->idt_outbufv)) {
			buf = idm_buf_find(&idt->idt_outbufv, 0);
			ASSERT(buf != NULL);

			mr = (iser_mr_t *)buf->idb_reg_private;
			ASSERT(mr != NULL);

			hdr->wsv_flag = 1;
			hdr->wstag = htonl(mr->is_mrrkey);
			BE_OUT64(&hdr->wva, mr->is_mrva);
		}

		/* Release our reference on the task */
		idm_task_rele(idt);
	}

	/* Copy the BHS after the iSER header */
	bcopy(pdu->isp_hdr,
	    (uint8_t *)(uintptr_t)msg->msg_ds.ds_va + ISER_HEADER_LENGTH,
	    pdu->isp_hdrlen);

	if (pdu->isp_datalen > 0) {
		/* Copy the isp_data after the PDU header */
		bcopy(pdu->isp_data,
		    (uint8_t *)(uintptr_t)msg->msg_ds.ds_va +
		    ISER_HEADER_LENGTH + pdu->isp_hdrlen,
		    pdu->isp_datalen);

		/* Set the SGE's ds_len */
		msg->msg_ds.ds_len = ISER_HEADER_LENGTH + pdu->isp_hdrlen +
		    pdu->isp_datalen;
	} else {
		/* No data, so set the SGE's ds_len to the headers length */
		msg->msg_ds.ds_len = ISER_HEADER_LENGTH + pdu->isp_hdrlen;
	}

	/*
	 * Build Work Request to be posted on the Send Queue.
	 */
	bzero(&wr, sizeof (wr));

	/* Allocate an iSER WR handle and tuck the msg and pdu into it */
	iser_wr = iser_wr_get();
	if (iser_wr == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_ctrlpdu: unable to allocate "
		    "iser wr handle");
		iser_msg_free(msg);
		mutex_exit(&chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}
	iser_wr->iw_pdu = pdu;
	iser_wr->iw_msg = msg;
	iser_wr->iw_type = ISER_WR_SEND;

	/*
	 * Use the address of our generic iser_wr handle as our WRID
	 * and populate the rest of the work request
	 */
	wr.wr_id	= (ibt_wrid_t)(uintptr_t)iser_wr;
	wr.wr_trans	= IBT_RC_SRV;
	wr.wr_opcode	= IBT_WRC_SEND;
	wr.wr_nds	= 1;
	wr.wr_sgl	= &msg->msg_ds;

	/* Increment this channel's SQ posted count */
	mutex_enter(&chan->ic_sq_post_lock);
	chan->ic_sq_post_count++;
	if (chan->ic_sq_post_count > chan->ic_sq_max_post_count)
		chan->ic_sq_max_post_count = chan->ic_sq_post_count;
	mutex_exit(&chan->ic_sq_post_lock);

	/* Post Send Work Request on the specified channel */
	status = ibt_post_send(chan->ic_chanhdl, &wr, 1, NULL);
	if (status != IBT_SUCCESS) {
		ISER_LOG(CE_NOTE, "iser_xfer_ctrlpdu: ibt_post_send "
		    "failure (%d)", status);
		iser_msg_free(msg);
		iser_wr_free(iser_wr);
		mutex_enter(&chan->ic_sq_post_lock);
		chan->ic_sq_post_count--;
		mutex_exit(&chan->ic_sq_post_lock);
		mutex_exit(&chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	mutex_exit(&chan->ic_conn->ic_lock);
	return (ISER_STATUS_SUCCESS);
}

/*
 * iser_xfer_buf_to_ini
 * This is iSER's implementation of the 'Put_Data' operational primitive.
 * The iSCSI layer at the target invokes this function when it is ready to
 * return the SCSI Read Data to the initiator. This function generates and
 * sends an RDMA Write Message containing the read data to the initiator.
 */
int
iser_xfer_buf_to_ini(idm_task_t *idt, idm_buf_t *buf)
{
	iser_conn_t	*iser_conn;
	iser_chan_t	*iser_chan;
	iser_buf_t	*iser_buf;
	iser_wr_t	*iser_wr;
	iser_ctrl_hdr_t	*iser_hdr;
	ibt_send_wr_t	wr;
	uint64_t	reg_raddr;
	uint32_t	reg_rkey;
	int		status;

	/* Grab the iSER resources from the task and buf handles */
	iser_conn = (iser_conn_t *)idt->idt_ic->ic_transport_private;
	iser_chan = iser_conn->ic_chan;

	mutex_enter(&iser_chan->ic_conn->ic_lock);
	/* Bail out if the connection is closed */
	if ((iser_chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSING) ||
	    (iser_chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSED)) {
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	iser_buf  = (iser_buf_t *)buf->idb_buf_private;
	iser_hdr  = (iser_ctrl_hdr_t *)idt->idt_transport_hdr;

	/* Pull the Read STag data out of the iSER header in the task hdl */
	reg_raddr = BE_IN64(&iser_hdr->rva);
	reg_rkey  = (ntohl(iser_hdr->rstag));

	/* Set up the WR raddr and rkey based upon the Read iSER STag */
	bzero(&wr, sizeof (ibt_send_wr_t));
	wr.wr.rc.rcwr.rdma.rdma_raddr = reg_raddr + buf->idb_bufoffset;
	wr.wr.rc.rcwr.rdma.rdma_rkey  = reg_rkey;

	/* Set the transfer length from the IDM buf handle */
	iser_buf->buf_ds.ds_len	= buf->idb_xfer_len;

	/* Allocate an iSER WR handle and tuck the IDM buf handle into it */
	iser_wr = iser_wr_get();
	if (iser_wr == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_buf_to_ini: unable to allocate "
		    "iser wr handle");
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}
	iser_wr->iw_buf = buf;
	iser_wr->iw_type = ISER_WR_RDMAW;

	/* Use the address of our generic iser_wr handle as our WRID */
	wr.wr_id	= (ibt_wrid_t)(uintptr_t)iser_wr;

	/* Populate the rest of the work request */
	wr.wr_flags	= IBT_WR_SEND_SIGNAL;
	wr.wr_trans	= IBT_RC_SRV;
	wr.wr_opcode	= IBT_WRC_RDMAW;
	wr.wr_nds	= 1;
	wr.wr_sgl	= &iser_buf->buf_ds;

#ifdef DEBUG
	bcopy(&wr, &iser_buf->buf_wr, sizeof (ibt_send_wr_t));
#endif

	DTRACE_ISCSI_8(xfer__start, idm_conn_t *, idt->idt_ic,
	    uintptr_t, buf->idb_buf, uint32_t, buf->idb_bufoffset,
	    uint64_t, reg_raddr, uint32_t, buf->idb_bufoffset,
	    uint32_t,  reg_rkey,
	    uint32_t, buf->idb_xfer_len, int, XFER_BUF_TX_TO_INI);

	/* Increment this channel's SQ posted count */
	mutex_enter(&iser_chan->ic_sq_post_lock);
	iser_chan->ic_sq_post_count++;
	if (iser_chan->ic_sq_post_count > iser_chan->ic_sq_max_post_count)
		iser_chan->ic_sq_max_post_count = iser_chan->ic_sq_post_count;
	mutex_exit(&iser_chan->ic_sq_post_lock);

	status = ibt_post_send(iser_chan->ic_chanhdl, &wr, 1, NULL);
	if (status != IBT_SUCCESS) {
		ISER_LOG(CE_NOTE, "iser_xfer_buf_to_ini: ibt_post_send "
		    "failure (%d)", status);
		iser_wr_free(iser_wr);
		mutex_enter(&iser_chan->ic_sq_post_lock);
		iser_chan->ic_sq_post_count--;
		mutex_exit(&iser_chan->ic_sq_post_lock);
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	mutex_exit(&iser_chan->ic_conn->ic_lock);
	return (ISER_STATUS_SUCCESS);
}

/*
 * iser_xfer_buf_from_ini
 * This is iSER's implementation of the 'Get_Data' operational primitive.
 * The iSCSI layer at the target invokes this function when it is ready to
 * receive the SCSI Write Data from the initiator. This function generates and
 * sends an RDMA Read Message to get the data from the initiator. No R2T PDUs
 * are generated.
 */
int
iser_xfer_buf_from_ini(idm_task_t *idt, idm_buf_t *buf)
{
	iser_conn_t	*iser_conn;
	iser_chan_t	*iser_chan;
	iser_buf_t	*iser_buf;
	iser_wr_t	*iser_wr;
	iser_ctrl_hdr_t	*iser_hdr;
	ibt_send_wr_t	wr;
	uint64_t	reg_raddr;
	uint32_t	reg_rkey;
	int		status;

	/* Grab the iSER resources from the task and buf handles */
	iser_conn = (iser_conn_t *)idt->idt_ic->ic_transport_private;
	iser_chan = iser_conn->ic_chan;

	mutex_enter(&iser_chan->ic_conn->ic_lock);
	/* Bail out if the connection is closed */
	if ((iser_chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSING) ||
	    (iser_chan->ic_conn->ic_stage == ISER_CONN_STAGE_CLOSED)) {
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	iser_buf = (iser_buf_t *)buf->idb_buf_private;
	iser_hdr  = (iser_ctrl_hdr_t *)idt->idt_transport_hdr;

	/* Pull the Write STag data out of the iSER header in the task hdl */
	reg_raddr = BE_IN64(&iser_hdr->wva);
	reg_rkey  = (ntohl(iser_hdr->wstag));

	/* Set up the WR raddr and rkey based upon the iSER Write STag */
	bzero(&wr, sizeof (ibt_send_wr_t));
	wr.wr.rc.rcwr.rdma.rdma_raddr = reg_raddr + buf->idb_bufoffset;
	wr.wr.rc.rcwr.rdma.rdma_rkey  = reg_rkey;

	/* Set the transfer length from the IDM buf handle */
	iser_buf->buf_ds.ds_len	= buf->idb_xfer_len;

	/* Allocate an iSER WR handle and tuck the IDM buf handle into it */
	iser_wr = iser_wr_get();
	if (iser_wr == NULL) {
		ISER_LOG(CE_NOTE, "iser_xfer_buf_from_ini: unable to allocate "
		    "iser wr handle");
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}
	iser_wr->iw_buf = buf;
	iser_wr->iw_type = ISER_WR_RDMAR;

	/* Use the address of our generic iser_wr handle as our WRID */
	wr.wr_id	= (ibt_wrid_t)(uintptr_t)iser_wr;

	/* Populate the rest of the work request */
	wr.wr_flags	= IBT_WR_SEND_SIGNAL;
	wr.wr_trans	= IBT_RC_SRV;
	wr.wr_opcode	= IBT_WRC_RDMAR;
	wr.wr_nds	= 1;
	wr.wr_sgl	= &iser_buf->buf_ds;

#ifdef DEBUG
	bcopy(&wr, &iser_buf->buf_wr, sizeof (ibt_send_wr_t));
#endif

	DTRACE_ISCSI_8(xfer__start, idm_conn_t *, idt->idt_ic,
	    uintptr_t, buf->idb_buf, uint32_t, buf->idb_bufoffset,
	    uint64_t, reg_raddr, uint32_t, buf->idb_bufoffset,
	    uint32_t,  reg_rkey,
	    uint32_t, buf->idb_xfer_len, int, XFER_BUF_RX_FROM_INI);

	/* Increment this channel's SQ posted count */
	mutex_enter(&iser_chan->ic_sq_post_lock);
	iser_chan->ic_sq_post_count++;
	if (iser_chan->ic_sq_post_count > iser_chan->ic_sq_max_post_count)
		iser_chan->ic_sq_max_post_count = iser_chan->ic_sq_post_count;
	mutex_exit(&iser_chan->ic_sq_post_lock);

	status = ibt_post_send(iser_chan->ic_chanhdl, &wr, 1, NULL);
	if (status != IBT_SUCCESS) {
		ISER_LOG(CE_NOTE, "iser_xfer_buf_from_ini: ibt_post_send "
		    "failure (%d)", status);
		iser_wr_free(iser_wr);
		mutex_enter(&iser_chan->ic_sq_post_lock);
		iser_chan->ic_sq_post_count--;
		mutex_exit(&iser_chan->ic_sq_post_lock);
		mutex_exit(&iser_chan->ic_conn->ic_lock);
		return (ISER_STATUS_FAIL);
	}

	mutex_exit(&iser_chan->ic_conn->ic_lock);
	return (ISER_STATUS_SUCCESS);
}