port/srpt/srpt_stp.c

/*
 * 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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * SCSI Target Port I/F for Solaris SCSI RDMA Protocol Target (SRP)
 * port provider module for the COMSTAR framework.
 */

#include <sys/cpuvar.h>
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/sysmacros.h>
#include <sys/sdt.h>
#include <sys/taskq.h>
#include <sys/atomic.h>

#include <sys/stmf.h>
#include <sys/stmf_ioctl.h>
#include <sys/portif.h>

#include <sys/scsi/generic/persist.h>
#include <sys/ib/mgt/ibdma/ibdma.h>

#include "srp.h"
#include "srpt_impl.h"
#include "srpt_cm.h"
#include "srpt_ioc.h"
#include "srpt_ch.h"
#include "srpt_stp.h"

extern srpt_ctxt_t  *srpt_ctxt;
extern uint32_t     srpt_iu_size;

/*
 * STMF LPort Interface Prototypes
 */
static stmf_status_t srpt_stp_xfer_data(struct scsi_task *task,
    struct stmf_data_buf *dbuf, uint32_t ioflags);
stmf_status_t srpt_stp_send_status(struct scsi_task *task,
    uint32_t ioflags);
static void srpt_stp_task_free(struct scsi_task *task);
static stmf_status_t srpt_stp_abort(struct stmf_local_port *lport,
    int abort_cmd, void *arg, uint32_t flags);
static void srpt_stp_task_poll(struct scsi_task *task);
static void srpt_stp_ctl(struct stmf_local_port *lport,
    int cmd, void *arg);
static stmf_status_t srpt_stp_info(uint32_t cmd,
    struct stmf_local_port *lport, void *arg, uint8_t *buf,
    uint32_t *bufsizep);
static void srpt_stp_event_handler(struct stmf_local_port *lport,
    int eventid, void *arg, uint32_t flags);

static void srpt_format_login_rsp(srp_login_req_t *req,
    srp_login_rsp_t *rsp, uint8_t flags);
static void srpt_format_login_rej(srp_login_req_t *req,
    srp_login_rej_t *rej, uint32_t reason);

static scsi_devid_desc_t *srpt_stp_alloc_scsi_devid_desc(uint64_t guid);
static void srpt_stp_free_scsi_devid_desc(scsi_devid_desc_t *sdd);

extern uint16_t srpt_send_msg_depth;

/*
 * srpt_stp_start_srp() - Start SRP service
 *
 * Enable the SRP service for the specified SCSI Target Port.
 */
int
srpt_stp_start_srp(srpt_target_port_t *tgt)
{
    ibt_status_t        status;
    ibdma_status_t      dma_status;
    int         port;
    srpt_ioc_t      *ioc;

    if (tgt == NULL) {
        SRPT_DPRINTF_L1("stp_start_srp, NULL SCSI target port");
        return (IBT_FAILURE);
    }

    if (tgt->tp_ioc == NULL) {
        SRPT_DPRINTF_L1("stp_start_srp, SCSI target port NULL"
            " IOC pointer");
        return (IBT_FAILURE);
    }
    ioc = tgt->tp_ioc;

    SRPT_DPRINTF_L2("stp_start_srp, register SRP service for"
        " svc_id (%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
    status = ibt_register_service(srpt_ctxt->sc_ibt_hdl,
        &tgt->tp_ibt_svc_desc, tgt->tp_ibt_svc_id, 1,
        &tgt->tp_ibt_svc_hdl, NULL);
    if (status != IBT_SUCCESS) {
        tgt->tp_ibt_svc_hdl = NULL;
        SRPT_DPRINTF_L1("stp_start_srp, SRP service creation err (%d)",
            status);
        return (status);
    }

    /*
     * Bind the service associated with the SCSI target port to
     * each active port of the I/O Controller.
     */
    for (port = 0; port < ioc->ioc_attr.hca_nports; port++) {
        status = srpt_ioc_svc_bind(tgt, port+1);
        if (status != IBT_SUCCESS &&
            status != IBT_HCA_PORT_NOT_ACTIVE) {
            SRPT_DPRINTF_L1("start_srp, Unable to bind"
                " service (%d)", status);
            goto srp_start_err;
        }
    }

    /* don't online if we have no active ports */
    if (tgt->tp_num_active_ports == 0) {
        SRPT_DPRINTF_L2("start_srp, no ports active for svc_id %016llx",
            (u_longlong_t)tgt->tp_ibt_svc_id);
        status = IBT_HCA_PORT_NOT_ACTIVE;
        goto srp_start_err;
    }

    tgt->tp_srp_enabled = 1;

    /*
     * Calculate the new I/O Controller profile and either update the
     * profile if previously registered or register it with the IB
     * Device Management Agent.
     */
    SRPT_DPRINTF_L3("start_srp, update I/O Controller profile (%016llx)",
        (u_longlong_t)ioc->ioc_guid);

    srpt_ioc_init_profile(ioc);
    if (ioc->ioc_ibdma_hdl == NULL) {
        ioc->ioc_ibdma_hdl =
            srpt_ctxt->sc_ibdma_ops.ibdma_register(ioc->ioc_guid,
            &ioc->ioc_profile, &ioc->ioc_svc);
        if (ioc->ioc_ibdma_hdl == NULL) {
            SRPT_DPRINTF_L1("start_srp, Unable to register"
                " I/O Profile for svc_id %016llx",
                (u_longlong_t)tgt->tp_ibt_svc_id);
            status = IBT_FAILURE;
            goto srp_start_err;
        }
    } else {
        dma_status =
            srpt_ctxt->sc_ibdma_ops.ibdma_update(ioc->ioc_ibdma_hdl,
            &ioc->ioc_profile, &ioc->ioc_svc);
        if (dma_status != IBDMA_SUCCESS) {
            SRPT_DPRINTF_L1("start_srp, Unable to update I/O"
                " Profile for svc_id %016llxi (%d)",
                (u_longlong_t)tgt->tp_ibt_svc_id, dma_status);
            status = IBT_FAILURE;
            goto srp_start_err;
        }
    }

    return (IBT_SUCCESS);

srp_start_err:
    tgt->tp_srp_enabled = 0;
    srpt_ioc_svc_unbind_all(tgt);
    tgt->tp_num_active_ports = 0;
    if (tgt->tp_ibt_svc_hdl != NULL) {
        (void) ibt_deregister_service(srpt_ctxt->sc_ibt_hdl,
            tgt->tp_ibt_svc_hdl);
        tgt->tp_ibt_svc_hdl = NULL;
    }
    return (status);
}

/*
 * srpt_stp_stop_srp() - Stop SRP service.
 *
 * Disable the SRP service on the specified SCSI Target Port.
 */
void
srpt_stp_stop_srp(srpt_target_port_t *tgt)
{
    ibt_status_t        status;
    ibdma_status_t      dma_status;
    srpt_ioc_t      *ioc;
    srpt_channel_t      *ch;

    if (tgt == NULL) {
        SRPT_DPRINTF_L2("stp_stop_srp, NULL SCSI Target Port"
            " specified");
        return;
    }

    if (tgt->tp_ioc == NULL) {
        SRPT_DPRINTF_L2("stp_stop_srp, bad Target, IOC NULL");
        return;
    }
    ioc = tgt->tp_ioc;

    /*
     * Update the I/O Controller profile to remove the SRP service
     * for this SCSI target port.
     */
    tgt->tp_srp_enabled = 0;

    if (ioc->ioc_ibdma_hdl != NULL) {
        SRPT_DPRINTF_L3("stp_stop_srp, update I/O Controller"
            " profile (%016llx)", (u_longlong_t)ioc->ioc_guid);
        srpt_ioc_init_profile(ioc);

        if (ioc->ioc_profile.ioc_service_entries == 0) {
            SRPT_DPRINTF_L3("stp_stop_srp, no services active"
                " unregister IOC profile");
            srpt_ctxt->sc_ibdma_ops.ibdma_unregister(
                ioc->ioc_ibdma_hdl);
            ioc->ioc_ibdma_hdl = NULL;
        } else {
            dma_status = srpt_ctxt->sc_ibdma_ops.ibdma_update(
                ioc->ioc_ibdma_hdl, &ioc->ioc_profile,
                &ioc->ioc_svc);
            if (dma_status != IBDMA_SUCCESS) {
                SRPT_DPRINTF_L1("stp_stop_srp, Unable to"
                    " update I/O Profile (%d)", dma_status);
                return;
            }
        }
    }

    /*
     * Unbind the SRP service associated with the SCSI target port
     * from all of the I/O Controller physical ports.
     */
    SRPT_DPRINTF_L2("stp_stop_srp, unbind and de-register service"
        "(%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
    if (tgt->tp_ibt_svc_hdl != NULL) {
        srpt_ioc_svc_unbind_all(tgt);
    }

    if (tgt->tp_ibt_svc_hdl != NULL) {
        status = ibt_deregister_service(srpt_ctxt->sc_ibt_hdl,
            tgt->tp_ibt_svc_hdl);
        if (status != IBT_SUCCESS) {
            SRPT_DPRINTF_L1("stp_stop_srp, de-register service"
                " error(%d)", status);
        }
        tgt->tp_ibt_svc_hdl = NULL;
    }

    /*
     * SRP service is now off-line for this SCSI Target Port.
     * We force a disconnect (i.e. SRP Target Logout) for any
     * active SRP logins.
     */
    mutex_enter(&tgt->tp_ch_list_lock);
    ch = list_head(&tgt->tp_ch_list);
    while (ch != NULL) {
        SRPT_DPRINTF_L3("stp_stop_srp, disconnect ch(%p)",
            (void *)ch);
        srpt_ch_disconnect(ch);
        ch = list_next(&tgt->tp_ch_list, ch);
    }
    mutex_exit(&tgt->tp_ch_list_lock);

    /*
     * wait for all sessions to terminate before returning
     */
    mutex_enter(&tgt->tp_sess_list_lock);
    while (!list_is_empty(&tgt->tp_sess_list)) {
        cv_wait(&tgt->tp_sess_complete, &tgt->tp_sess_list_lock);
    }
    mutex_exit(&tgt->tp_sess_list_lock);
}

/*
 * srpt_stp_alloc_port() - Allocate SCSI Target Port
 */
srpt_target_port_t *
srpt_stp_alloc_port(srpt_ioc_t *ioc, ib_guid_t guid)
{
    stmf_status_t       status;
    srpt_target_port_t  *tgt;
    stmf_local_port_t   *lport;
    uint64_t        temp;

    if (ioc == NULL) {
        SRPT_DPRINTF_L1("stp_alloc_port, NULL I/O Controller");
        return (NULL);
    }

    SRPT_DPRINTF_L3("stp_alloc_port, allocate STMF local port");
    lport = stmf_alloc(STMF_STRUCT_STMF_LOCAL_PORT, sizeof (*tgt), 0);
    if (lport == NULL) {
        SRPT_DPRINTF_L1("tgt_alloc_port, stmf_alloc failed");
        return (NULL);
    }

    tgt = lport->lport_port_private;
    ASSERT(tgt != NULL);

    mutex_init(&tgt->tp_lock, NULL, MUTEX_DRIVER, NULL);

    mutex_init(&tgt->tp_ch_list_lock, NULL, MUTEX_DRIVER, NULL);
    cv_init(&tgt->tp_offline_complete, NULL, CV_DRIVER, NULL);
    list_create(&tgt->tp_ch_list, sizeof (srpt_channel_t),
        offsetof(srpt_channel_t, ch_stp_node));

    mutex_init(&tgt->tp_sess_list_lock, NULL, MUTEX_DRIVER, NULL);
    cv_init(&tgt->tp_sess_complete, NULL, CV_DRIVER, NULL);
    list_create(&tgt->tp_sess_list, sizeof (srpt_session_t),
        offsetof(srpt_session_t, ss_node));

    tgt->tp_state    = SRPT_TGT_STATE_OFFLINE;
    tgt->tp_drv_disabled  = 0;
    tgt->tp_srp_enabled   = 0;
    tgt->tp_lport    = lport;
    tgt->tp_ioc    = ioc;
    tgt->tp_ibt_svc_id = guid;
    tgt->tp_ibt_svc_desc.sd_handler = srpt_cm_hdlr;
    tgt->tp_ibt_svc_desc.sd_flags   = IBT_SRV_NO_FLAGS;
    temp = h2b64(tgt->tp_ibt_svc_id);
    bcopy(&temp, &tgt->tp_srp_port_id[0], 8);
    temp = h2b64(tgt->tp_ioc->ioc_guid);
    bcopy(&temp, &tgt->tp_srp_port_id[8], 8);

    tgt->tp_nports  = ioc->ioc_attr.hca_nports;
    tgt->tp_hw_port =
        kmem_zalloc(sizeof (srpt_hw_port_t) * tgt->tp_nports, KM_SLEEP);
    tgt->tp_num_active_ports = 0;
    tgt->tp_requested_state = SRPT_TGT_STATE_OFFLINE;

    tgt->tp_scsi_devid = srpt_stp_alloc_scsi_devid_desc(tgt->tp_ibt_svc_id);

    lport->lport_id = tgt->tp_scsi_devid;
    lport->lport_pp = srpt_ctxt->sc_pp;
    lport->lport_ds = ioc->ioc_stmf_ds;
    lport->lport_xfer_data  = &srpt_stp_xfer_data;
    lport->lport_send_status = &srpt_stp_send_status;
    lport->lport_task_free  = &srpt_stp_task_free;
    lport->lport_abort  = &srpt_stp_abort;
    lport->lport_abort_timeout = 300;   /* 5 minutes */
    lport->lport_task_poll  = &srpt_stp_task_poll;
    lport->lport_ctl    = &srpt_stp_ctl;
    lport->lport_info   = &srpt_stp_info;
    lport->lport_event_handler = &srpt_stp_event_handler;

    /* set up as alua participating port */
    stmf_set_port_alua(lport);

    SRPT_DPRINTF_L3("stp_alloc_port, register STMF LPORT");

retry_registration:
    status = stmf_register_local_port(lport);
    if (status == STMF_SUCCESS) {
        SRPT_DPRINTF_L3("stp_alloc_port, LPORT successfully"
            " registered");
        return (tgt);
    }

    if (status == STMF_BUSY) {
        /*
         * This is only done on an administrative thread of
         * execution so it is ok to take a while.
         */
        SRPT_DPRINTF_L3("stp_alloc_port, delaying");
        delay(2 * drv_usectohz(1000000));
        goto retry_registration;
    }
    SRPT_DPRINTF_L1("stp_alloc_port, STMF register local port err(0x%llx)",
        (u_longlong_t)status);

    SRPT_DPRINTF_L3("stp_alloc_port, free STMF local port");
    cv_destroy(&tgt->tp_offline_complete);
    mutex_destroy(&tgt->tp_ch_list_lock);
    mutex_destroy(&tgt->tp_lock);
    if (tgt->tp_hw_port) {
        kmem_free(tgt->tp_hw_port,
            sizeof (srpt_hw_port_t) * tgt->tp_nports);
    }
    if (tgt->tp_scsi_devid) {
        srpt_stp_free_scsi_devid_desc(tgt->tp_scsi_devid);
    }

    stmf_free(lport);

    return (NULL);
}

/*
 * srpt_stp_free_port() - Free SCSI Target Port
 */
stmf_status_t
srpt_stp_free_port(srpt_target_port_t *tgt)
{
    ASSERT(tgt != NULL);
    ASSERT(list_is_empty(&tgt->tp_sess_list));
    ASSERT(list_is_empty(&tgt->tp_ch_list));

    list_destroy(&tgt->tp_ch_list);
    list_destroy(&tgt->tp_sess_list);

    cv_destroy(&tgt->tp_sess_complete);
    cv_destroy(&tgt->tp_offline_complete);

    mutex_destroy(&tgt->tp_sess_list_lock);
    mutex_destroy(&tgt->tp_ch_list_lock);
    mutex_destroy(&tgt->tp_lock);


    SRPT_DPRINTF_L3("stp_free_port, free STMF local port");
    if (tgt->tp_hw_port) {
        kmem_free(tgt->tp_hw_port,
            sizeof (srpt_hw_port_t) * tgt->tp_nports);
    }

    if (tgt->tp_scsi_devid) {
        srpt_stp_free_scsi_devid_desc(tgt->tp_scsi_devid);
    }

    stmf_free(tgt->tp_lport);

    return (STMF_SUCCESS);
}

/*
 * srpt_stp_destroy_port()
 */
stmf_status_t
srpt_stp_destroy_port(srpt_target_port_t *tgt)
{
    stmf_status_t       status;
    stmf_change_status_t    cstatus;
    uint64_t        guid;

    ASSERT(tgt != NULL);
    ASSERT(tgt->tp_lport != NULL);

    SRPT_DPRINTF_L3("stp_destroy_port, de-register STMF LPORT");

    mutex_enter(&tgt->tp_lock);
    if (tgt->tp_drv_disabled != 0) {
        /* already being destroyed, get out now - should not happen */
        mutex_exit(&tgt->tp_lock);
        return (STMF_ALREADY);
    }

    tgt->tp_drv_disabled = 1;
    guid = tgt->tp_ioc->ioc_guid;
    mutex_exit(&tgt->tp_lock);

    SRPT_DPRINTF_L2("stp_destroy_port: unbind and de-register"
        " services for GUID(%016llx)", (u_longlong_t)guid);

    cstatus.st_completion_status = STMF_SUCCESS;
    cstatus.st_additional_info = NULL;

    status = stmf_ctl(STMF_CMD_LPORT_OFFLINE, tgt->tp_lport, &cstatus);

    /*
     * Wait for asynchronous target off-line operation
     * to complete and then deregister the target
     * port.
     */
    mutex_enter(&tgt->tp_lock);
    while (tgt->tp_state != SRPT_TGT_STATE_OFFLINE) {
        cv_wait(&tgt->tp_offline_complete, &tgt->tp_lock);
    }
    mutex_exit(&tgt->tp_lock);

    SRPT_DPRINTF_L3("stp_destroy_port: IOC (0x%016llx) Target"
        " SRP off-line complete", (u_longlong_t)guid);

    /* loop waiting for all I/O to drain */
    for (;;) {
        status = stmf_deregister_local_port(tgt->tp_lport);
        if (status == STMF_BUSY) {
            delay(drv_usectohz(1000000));
        } else {
            break;
        }
    }

    if (status == STMF_SUCCESS) {
        SRPT_DPRINTF_L3("stp_destroy_port, LPORT de-register"
            " complete");
    } else {
        /*
         * Something other than a BUSY error, this should not happen.
         */
        SRPT_DPRINTF_L1(
            "stp_destroy_port, de-register STMF error(0x%llx)",
            (u_longlong_t)status);
    }

    return (status);
}

/*
 * srpt_stp_xfer_data()
 */
/* ARGSUSED */
static stmf_status_t
srpt_stp_xfer_data(struct scsi_task *task, struct stmf_data_buf *dbuf,
    uint32_t ioflags)
{
    srpt_iu_t       *iu;
    srpt_channel_t      *ch;
    srpt_ds_dbuf_t      *db;
    ibt_send_wr_t       wr;
    ibt_wr_ds_t     ds;
    ibt_status_t        status;
    uint32_t        xfer_len;
    uint32_t        xferred_len;
    uint32_t        rdma_len;
    uint32_t        base_offset;
    uint32_t        desc_offset;
    srp_direct_desc_t   *desc;

    SRPT_DPRINTF_L3("stp_xfer_data, invoked task (%p), dbuf (%p)",
        (void *)task, (void *)dbuf);
    iu = task->task_port_private;
    ASSERT(iu != NULL);
    ASSERT(iu->iu_ch != NULL);
    /*
     * We should use iu->iu_ch->ch_swqe_posted to throttle
     * send wqe posting. This is very unlikely because we limit
     * the maximum number of initiator descriptors per IU (impact
     * of fragmentation of intiator buffer space) but it could occur
     * if the back-end (STMF) were to use too many small buffers. In
     * that case we would want to return STMF_BUSY.
     */

    SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_flags (0x%x)",
        dbuf->db_flags);
    SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_data_size (%d)",
        dbuf->db_data_size);
    SRPT_DPRINTF_L4("stp_xfer_data, dbuf->db_relative_offset (%d)",
        dbuf->db_relative_offset);

    ASSERT((dbuf->db_flags & (DB_DIRECTION_TO_RPORT |
        DB_DIRECTION_FROM_RPORT)) != (DB_DIRECTION_TO_RPORT |
        DB_DIRECTION_FROM_RPORT));

    db = dbuf->db_port_private;

    /*
     * Check to see if request will overflow the remote buffer; if so
     * return a bad status and let STMF abort the task.
     */
    if ((dbuf->db_relative_offset + dbuf->db_data_size) >
        iu->iu_tot_xfer_len) {
        SRPT_DPRINTF_L2("stp_xfer_data, overflow of remote buffer");
        return (STMF_FAILURE);
    }

    db->db_iu   = iu;
    wr.wr_trans  = IBT_RC_SRV;
    wr.wr_opcode = (dbuf->db_flags & DB_DIRECTION_TO_RPORT) ?
        IBT_WRC_RDMAW : IBT_WRC_RDMAR;
    wr.wr_nds    = 1;
    wr.wr_sgl    = &ds;

    /*
     * We know that the data transfer is within the bounds described
     * by our list of remote buffer descriptors.  Find the starting
     * point based on the offset for the transfer, then perform the
     * RDMA operations required of this transfer.
     */
    base_offset = 0;
    desc = iu->iu_rdescs;

    while ((base_offset + desc->dd_len) < dbuf->db_relative_offset) {
        base_offset += desc->dd_len;
        desc++;
    }

    xfer_len    = dbuf->db_data_size;
    xferred_len = 0;
    desc_offset = dbuf->db_relative_offset - base_offset;

    ch = iu->iu_ch;

    /*
     * If the channel is no longer connected then return an
     * error and do not initiate I/O.  STMF should abort the
     * task.
     */
    rw_enter(&ch->ch_rwlock, RW_READER);

    if (iu->iu_ch->ch_state == SRPT_CHANNEL_DISCONNECTING) {
        rw_exit(&iu->iu_ch->ch_rwlock);
        return (STMF_FAILURE);
    }

    while (xfer_len > 0) {
        rdma_len = desc->dd_len - desc_offset;

        /*
         * We only generate completion entries on the last IB
         * operation associated with any STMF buffer.
         */
        if (rdma_len >= xfer_len) {
            rdma_len = xfer_len;
            wr.wr_flags  = IBT_WR_SEND_SIGNAL;
        } else {
            wr.wr_flags  = IBT_WR_NO_FLAGS;
        }

        wr.wr.rc.rcwr.rdma.rdma_raddr = desc->dd_vaddr + desc_offset;
        wr.wr.rc.rcwr.rdma.rdma_rkey  = desc->dd_hdl;
        ds.ds_va  = db->db_sge.ds_va + xferred_len;
        ds.ds_key = db->db_sge.ds_key;
        ds.ds_len = rdma_len;

        SRPT_DPRINTF_L4("stp_xfer_data, post RDMA operation");

        /*
         * If this task is being aborted or has been aborted,
         * do not post additional I/O.
         */
        DTRACE_SRP_8(xfer__start, srpt_channel_t, ch,
            ibt_wr_ds_t, &(db->db_sge), srpt_iu_t, iu,
            ibt_send_wr_t, &wr, uint32_t, rdma_len,
            uint32_t, xferred_len, uint32_t, desc_offset,
            uint32_t, wr.wr_opcode == IBT_WRC_RDMAR ? 0 : 1);
        mutex_enter(&iu->iu_lock);
        if ((iu->iu_flags & (SRPT_IU_SRP_ABORTING |
            SRPT_IU_STMF_ABORTING | SRPT_IU_ABORTED)) != 0) {
            mutex_exit(&iu->iu_lock);
            rw_exit(&iu->iu_ch->ch_rwlock);
            return (STMF_SUCCESS);
        }

        /*
         * If a non-error CQE will be requested, add a reference to
         * the IU and initialize the work request appropriately.
         */
        if ((wr.wr_flags & IBT_WR_SEND_SIGNAL) != 0) {
            wr.wr_id = srpt_ch_alloc_swqe_wrid(ch,
                SRPT_SWQE_TYPE_DATA, (void *)dbuf);
            if (wr.wr_id == 0) {
                rw_exit(&iu->iu_ch->ch_rwlock);
                mutex_exit(&iu->iu_lock);
                return (STMF_BUSY);
            }
            atomic_inc_32(&iu->iu_sq_posted_cnt);
        } else {
            wr.wr_id = 0;
        }

        status = ibt_post_send(iu->iu_ch->ch_chan_hdl, &wr, 1, NULL);
        mutex_exit(&iu->iu_lock);

        if (status != IBT_SUCCESS) {
            /*
             * Could not post to IB transport, report to STMF and
             * and let it initiate an abort of the task.
             */
            SRPT_DPRINTF_L2("stp_xfer_data, post RDMA"
                " error (%d)", status);

            if ((wr.wr_flags & IBT_WR_SEND_SIGNAL) != 0) {
                srpt_ch_free_swqe_wrid(ch, wr.wr_id);
                atomic_dec_32(&iu->iu_sq_posted_cnt);
            }
            rw_exit(&iu->iu_ch->ch_rwlock);
            return (STMF_FAILURE);
        }
        xferred_len += rdma_len;
        xfer_len    -= rdma_len;
        desc_offset  = 0;
        desc++;
    }

    rw_exit(&ch->ch_rwlock);
    return (STMF_SUCCESS);
}

/*
 * srpt_stp_send_mgmt_response() - Return SRP task managment response IU
 */
ibt_status_t
srpt_stp_send_mgmt_response(srpt_iu_t *iu, uint8_t srp_rsp,
    uint_t fence)
{
    srp_rsp_t   *rsp;
    srp_rsp_data_t  *data;
    uint32_t    rsp_length;
    ibt_status_t    status;
    uint8_t     *bufp;

    ASSERT(mutex_owned(&iu->iu_lock));
    rsp = iu->iu_buf;
    bufp = (uint8_t *)iu->iu_buf + SRP_RSP_SIZE;
    bzero(rsp, SRP_RSP_SIZE + sizeof (srp_rsp_data_t));
    rsp->rsp_type = SRP_IU_RSP;

    /*
     * Report ULP credits we have added since last response sent
     * over this channel.
     */
    rsp->rsp_req_limit_delta =
        h2b32(atomic_swap_32(&iu->iu_ch->ch_req_lim_delta, 0));
    rsp->rsp_tag = iu->iu_tag;

    /* srp_rsp_t is padded out, so use explicit size here */
    rsp_length = SRP_RSP_SIZE;
    if (srp_rsp != SRP_TM_SUCCESS) {
        rsp->rsp_flags |= SRP_RSP_VALID;
        data = (srp_rsp_data_t *)bufp;
        data->rd_rsp_status = srp_rsp;
        rsp->rsp_data_len = h2b32(sizeof (srp_rsp_data_t));
        rsp_length += sizeof (srp_rsp_data_t);
    }

    SRPT_DPRINTF_L4("stp_send_mgmt_response, sending on ch(%p),"
        " iu(%p), mgmt status(%d)", (void *)iu->iu_ch,
        (void *)iu, srp_rsp);

    DTRACE_SRP_4(task__response, srpt_channel_t, iu->iu_ch,
        srp_rsp_t, iu->iu_buf, scsi_task_t, iu->iu_stmf_task,
        int8_t, srp_rsp);

    status = srpt_ch_post_send(iu->iu_ch, iu, rsp_length, fence);
    if (status != IBT_SUCCESS) {
        SRPT_DPRINTF_L2("stp_send_mgmt_response, post "
            "response err(%d)", status);
    }
    return (status);
}

/*
 * srpt_stp_send_response() - Send SRP command response IU
 */
ibt_status_t
srpt_stp_send_response(srpt_iu_t *iu, uint8_t scsi_status,
    uint8_t flags, uint32_t resid, uint16_t sense_length,
    uint8_t *sense_data, uint_t fence)
{
    srp_rsp_t   *rsp;
    uint32_t    rsp_length;
    uint8_t     *bufp;
    ibt_status_t    status;

    ASSERT(mutex_owned(&iu->iu_lock));
    rsp = iu->iu_buf;
    bufp = (uint8_t *)iu->iu_buf + SRP_RSP_SIZE;
    bzero(rsp, SRP_RSP_SIZE);
    rsp->rsp_type = SRP_IU_RSP;

    /*
     * Report ULP credits we have added since last response sent
     * over this channel.
     */
    rsp->rsp_req_limit_delta =
        h2b32(atomic_swap_32(&iu->iu_ch->ch_req_lim_delta, 0));
    rsp->rsp_tag = iu->iu_tag;
    rsp->rsp_status = scsi_status;

    rsp_length = SRP_RSP_SIZE;

    if (resid != 0) {
        rsp->rsp_flags |= flags;

        if ((flags & SRP_RSP_DO_OVER) ||
            (flags & SRP_RSP_DO_UNDER)) {
            rsp->rsp_do_resid_cnt = h2b32(resid);
        } else if ((flags & SRP_RSP_DI_OVER) ||
            (flags & SRP_RSP_DI_UNDER)) {
            rsp->rsp_di_resid_cnt = h2b32(resid);
        }
    }

    if (sense_length != 0) {
        rsp->rsp_flags |= SRP_RSP_SNS_VALID;
        if (SRP_RSP_SIZE + sense_length >
            iu->iu_ch->ch_ti_iu_len) {
            sense_length = iu->iu_ch->ch_ti_iu_len -
                SRP_RSP_SIZE;
        }
        bcopy(sense_data, bufp, sense_length);
        rsp->rsp_sense_data_len = h2b32(sense_length);
        rsp_length += sense_length;
    }

    SRPT_DPRINTF_L4("stp_send_reponse, sending on ch(%p),"
        " iu(%p), length(%d)", (void *)iu->iu_ch,
        (void *)iu, rsp_length);

    DTRACE_SRP_4(task__response, srpt_channel_t, iu->iu_ch,
        srp_rsp_t, iu->iu_buf, scsi_task_t, iu->iu_stmf_task,
        uint8_t, scsi_status);

    status = srpt_ch_post_send(iu->iu_ch, iu, rsp_length, fence);
    if (status != IBT_SUCCESS) {
        SRPT_DPRINTF_L2("stp_send_response, post response err(%d)",
            status);
    }
    return (status);
}

/*
 * srpt_stp_send_status()
 */
/* ARGSUSED */
stmf_status_t
srpt_stp_send_status(struct scsi_task *task, uint32_t ioflags)
{
    srpt_iu_t   *iu;
    ibt_status_t    status;

    ASSERT(task != NULL);
    iu = task->task_port_private;

    ASSERT(iu != NULL);

    mutex_enter(&iu->iu_lock);

    ASSERT(iu->iu_ch != NULL);

    SRPT_DPRINTF_L3("stp_send_status, invoked task (%p)"
        ", task_completion_status (%d)"
        ", task_resid (%d)"
        ", task_status_ctrl (%d)"
        ", task_scsi_status (%d)"
        ", task_sense_length (%d)"
        ", task_sense_data (%p)",
        (void *)task,
        (int)task->task_completion_status,
        task->task_resid,
        task->task_status_ctrl,
        task->task_scsi_status,
        task->task_sense_length,
        (void *)task->task_sense_data);

    DTRACE_SRP_4(scsi__response, srpt_channel_t, iu->iu_ch,
        srp_rsp_t, iu->iu_buf, scsi_task_t, task,
        int8_t, task->task_scsi_status);

    if ((iu->iu_flags & (SRPT_IU_STMF_ABORTING |
        SRPT_IU_SRP_ABORTING | SRPT_IU_ABORTED)) != 0) {
        mutex_exit(&iu->iu_lock);
        return (STMF_FAILURE);
    }

    /*
     * Indicate future aborts can not be initiated (although
     * we will handle any that have been requested since the
     * last I/O completed and before we are sending status).
     */
    iu->iu_flags |= SRPT_IU_RESP_SENT;

    /*
     * Send SRP command response or SRP task mgmt response.
     */
    if (task->task_mgmt_function == 0) {
        uint8_t     rsp_flags = 0;
        uint32_t    resbytes = 0;

        if (task->task_status_ctrl == TASK_SCTRL_OVER) {
            resbytes = task->task_resid;

            if (task->task_flags & TF_READ_DATA) {
                SRPT_DPRINTF_L3(
                    "stp_send_status, data out overrun");
                rsp_flags |= SRP_RSP_DO_OVER;
            } else if (task->task_flags & TF_WRITE_DATA) {
                SRPT_DPRINTF_L3(
                    "stp_send_status, data in overrun");
                rsp_flags |= SRP_RSP_DI_OVER;
            }
        } else if (task->task_status_ctrl == TASK_SCTRL_UNDER) {
            resbytes = task->task_resid;

            if (task->task_flags & TF_READ_DATA) {
                SRPT_DPRINTF_L3(
                    "stp_send_status, data out underrun");
                rsp_flags |= SRP_RSP_DO_UNDER;
            } else if (task->task_flags & TF_WRITE_DATA) {
                SRPT_DPRINTF_L3(
                    "stp_send_status, data in underrun");
                rsp_flags |= SRP_RSP_DI_UNDER;
            }
        }

        status = srpt_stp_send_response(iu,
            task->task_scsi_status, rsp_flags, resbytes,
            task->task_sense_length, task->task_sense_data, 0);
    } else {
        status = srpt_stp_send_mgmt_response(iu,
            (task->task_scsi_status ?
            SRP_TM_FAILED : SRP_TM_SUCCESS),
            SRPT_FENCE_SEND);
    }

    /*
     * If we have an error posting the response return bad status
     * to STMF and let it initiate an abort for the task.
     */
    if (status != IBT_SUCCESS) {
        SRPT_DPRINTF_L2("stp_send_status, post response err(%d)",
            status);

        /* clear the response sent flag since it never went out */
        iu->iu_flags &= ~SRPT_IU_RESP_SENT;

        mutex_exit(&iu->iu_lock);
        return (STMF_FAILURE);
    }
    mutex_exit(&iu->iu_lock);
    return (STMF_SUCCESS);
}

/*
 * srpt_stp_task_free() - STMF call-back.
 */
static void
srpt_stp_task_free(struct scsi_task *task)
{
    srpt_iu_t   *iu;
    srpt_channel_t  *ch;

    SRPT_DPRINTF_L3("stp_task_free, invoked task (%p)",
        (void *)task);

    iu = task->task_port_private;
    ASSERT(iu != NULL);

    mutex_enter(&iu->iu_lock);
    ch = iu->iu_ch;
    mutex_exit(&iu->iu_lock);

    ASSERT(ch != NULL);
    ASSERT(ch->ch_session != NULL);

    /*
     * Do not hold IU lock while task is being removed from
     * the session list - possible deadlock if cleaning up
     * channel when this is called.
     */
    srpt_stp_remove_task(ch->ch_session, iu);

    mutex_enter(&iu->iu_lock);
    iu->iu_stmf_task = NULL;

    srpt_ioc_repost_recv_iu(iu->iu_ioc, iu);

    mutex_exit(&iu->iu_lock);

    srpt_ch_release_ref(ch, 0);
}

/*
 * srpt_stp_abort() - STMF call-back.
 */
/* ARGSUSED */
static stmf_status_t
srpt_stp_abort(struct stmf_local_port *lport, int abort_cmd,
    void *arg, uint32_t flags)
{
    struct scsi_task    *task;
    srpt_iu_t       *iu;
    stmf_status_t       status;

    SRPT_DPRINTF_L3("stp_abort, invoked lport (%p), arg (%p)",
        (void *)lport, (void *)arg);

    task = (struct scsi_task *)arg;
    ASSERT(task != NULL);

    iu = (srpt_iu_t *)task->task_port_private;
    ASSERT(iu != NULL);

    mutex_enter(&iu->iu_lock);

    /*
     * If no I/O is outstanding then immediately transition to
     * aborted state.  If any I/O is in progress OR we've sent the
     * completion response, then indicate that an STMF abort has been
     * requested and ask STMF to call us back later to complete the abort.
     */
    if ((iu->iu_flags & SRPT_IU_RESP_SENT) ||
        (iu->iu_sq_posted_cnt > 0)) {
        SRPT_DPRINTF_L3("stp_abort, deferring abort request. "
            "%d outstanding I/O for IU %p",
            iu->iu_sq_posted_cnt, (void *)iu);
        iu->iu_flags |= SRPT_IU_STMF_ABORTING;
        status = STMF_BUSY;
    } else {
        SRPT_DPRINTF_L3("stp_abort, no outstanding I/O for %p",
            (void *)iu);
        iu->iu_flags |= SRPT_IU_ABORTED;
        /* Synchronous abort - STMF will call task_free */
        status = STMF_ABORT_SUCCESS;
    }

    mutex_exit(&iu->iu_lock);
    return (status);
}

/*
 * srpt_stp_task_poll() - STMF call-back
 */
static void
srpt_stp_task_poll(struct scsi_task *task)
{
    SRPT_DPRINTF_L3("stp_task_poll, invoked, task (%p)",
        (void *)task);
}

/*
 * srpt_stp_ctl() - STMF call-back
 */
static void
srpt_stp_ctl(struct stmf_local_port *lport, int cmd, void *arg)
{
    stmf_state_change_info_t    *sc_info = arg;
    stmf_change_status_t        cstatus;
    stmf_status_t           status;
    srpt_target_port_t      *tgt;
    char                *why;

    ASSERT(sc_info != NULL);
    ASSERT(lport != NULL);

    tgt = lport->lport_port_private;
    ASSERT(tgt->tp_ioc != NULL);

    why = sc_info->st_additional_info;
    if (why == NULL) {
        why = "<null>";
    }

    SRPT_DPRINTF_L2("stp_ctl, invoked for LPORT (0x%016llx), cmd (%d), "
        "info (%s)", (u_longlong_t)tgt->tp_ibt_svc_id, cmd, why);

    cstatus.st_completion_status = STMF_SUCCESS;
    cstatus.st_additional_info = NULL;

    switch (cmd) {
    case STMF_CMD_LPORT_ONLINE:
        SRPT_DPRINTF_L2("stp_ctl, LPORT_ONLINE command,"
            " st_rflags(0x%llx)", (u_longlong_t)sc_info->st_rflags);
        /*
         * If the SCSI Target Port is not enabled by the driver,
         * don't start and instead return busy.  This is a
         * creation/destruction transitional state and the will
         * either go away or become enabled.
         */
        mutex_enter(&tgt->tp_lock);

        tgt->tp_requested_state = SRPT_TGT_STATE_ONLINE;

        if (tgt->tp_drv_disabled != 0) {
            SRPT_DPRINTF_L1("stp_ctl, set LPORT_ONLINE failed - "
                "LPORT (0x%016llx) BUSY",
                (u_longlong_t)tgt->tp_ibt_svc_id);
            cstatus.st_completion_status = STMF_BUSY;
        } else if ((tgt->tp_state == SRPT_TGT_STATE_ONLINE) ||
            (tgt->tp_state == SRPT_TGT_STATE_ONLINING)) {
            cstatus.st_completion_status = STMF_ALREADY;
        } else if (tgt->tp_state != SRPT_TGT_STATE_OFFLINE) {
            cstatus.st_completion_status = STMF_INVALID_ARG;
        } else {
            tgt->tp_state = SRPT_TGT_STATE_ONLINING;
            status = srpt_stp_start_srp(tgt);
            if (status != IBT_SUCCESS) {
                tgt->tp_state = SRPT_TGT_STATE_OFFLINE;
                cstatus.st_completion_status = STMF_INVALID_ARG;
                if (tgt->tp_num_active_ports == 0) {
                    SRPT_DPRINTF_L1(
                        "stp_ctl, no ports active "
                        "for HCA 0x%016llx. Target will "
                        "not be placed online.",
                        (u_longlong_t)tgt->tp_ibt_svc_id);
                }
            }
        }
        mutex_exit(&tgt->tp_lock);
        SRPT_DPRINTF_L3("stp_ctl, (0x%016llx) LPORT_ONLINE command"
            " status (0x%llx)", (u_longlong_t)tgt->tp_ibt_svc_id,
            (u_longlong_t)cstatus.st_completion_status);
        status = stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, lport,
            &cstatus);
        if (status != STMF_SUCCESS) {
            SRPT_DPRINTF_L1("stp_ctl, ONLINE_COMPLETE returned"
                " error(0x%llx)", (u_longlong_t)status);
        }
        break;

    case STMF_CMD_LPORT_OFFLINE:
        SRPT_DPRINTF_L2("stp_ctl, LPORT_OFFLINE command,"
            " st_rflags(0x%llx)", (u_longlong_t)sc_info->st_rflags);
        mutex_enter(&tgt->tp_lock);

        /*
         * Only keep persistent state if explicitly requested by user
         * action, such as stmfadm offline-target or
         * svcadm disable stmf.
         * If not requested by the user, this was likely triggered by
         * not having any HCA ports active.
         */
        if (sc_info->st_rflags & STMF_RFLAG_USER_REQUEST) {
            tgt->tp_requested_state = SRPT_TGT_STATE_OFFLINE;
        }

        if ((tgt->tp_state == SRPT_TGT_STATE_OFFLINE) ||
            (tgt->tp_state == SRPT_TGT_STATE_OFFLINING)) {
            cstatus.st_completion_status = STMF_ALREADY;
        } else if (tgt->tp_state != SRPT_TGT_STATE_ONLINE) {
            cstatus.st_completion_status = STMF_INVALID_ARG;
        } else {
            tgt->tp_state = SRPT_TGT_STATE_OFFLINING;
            srpt_stp_stop_srp(tgt);
        }
        mutex_exit(&tgt->tp_lock);
        SRPT_DPRINTF_L3("stp_ctl, notify STMF OFFLINE complete"
            " (0x%016llx)", (u_longlong_t)tgt->tp_ibt_svc_id);
        status = stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE,
            lport, &cstatus);
        if (status != STMF_SUCCESS) {
            SRPT_DPRINTF_L1("stp_ctl, OFFLINE_COMPLETE returned"
                " error(0x%llx)", (u_longlong_t)status);
        }
        break;

    case STMF_ACK_LPORT_ONLINE_COMPLETE:
        SRPT_DPRINTF_L2("stp_ctl, LPORT_ONLINE_COMPLETE ACK from"
            " STMF");
        mutex_enter(&tgt->tp_lock);
        if (tgt->tp_state == SRPT_TGT_STATE_ONLINING) {
            SRPT_DPRINTF_L2("stp_ctl, LPORT is ONLINE");
            tgt->tp_state = SRPT_TGT_STATE_ONLINE;
        } else {
            SRPT_DPRINTF_L2("stp_ctl, LPORT not on-lining");
        }
        mutex_exit(&tgt->tp_lock);
        break;

    case STMF_ACK_LPORT_OFFLINE_COMPLETE:
        SRPT_DPRINTF_L2("stp_ctl, LPORT_OFFLINE_COMPLETE ACK from"
            " STMF");
        mutex_enter(&tgt->tp_lock);
        if (tgt->tp_state == SRPT_TGT_STATE_OFFLINING) {
            SRPT_DPRINTF_L2("stp_ctl, LPORT is OFFLINE");
            tgt->tp_state = SRPT_TGT_STATE_OFFLINE;
            cv_broadcast(&tgt->tp_offline_complete);
        } else {
            SRPT_DPRINTF_L2("stp_ctl, LPORT not off-lining");
        }
        mutex_exit(&tgt->tp_lock);
        break;

    default:
        SRPT_DPRINTF_L2("stp_ctl, cmd (%d) not handled",
            cmd);
        break;
    }
}

/*
 * srpt_stp_info() - STMF call-back
 */
/* ARGSUSED */
static stmf_status_t
srpt_stp_info(uint32_t cmd, struct stmf_local_port *lport,
    void *arg, uint8_t *buf, uint32_t *bufsizep)
{
    SRPT_DPRINTF_L3("stp_info, invoked");
    return (STMF_SUCCESS);
}

/*
 * srpt_stp_event_handler() - STMF call-back
 */
/* ARGSUSED */
static void
srpt_stp_event_handler(struct stmf_local_port *lport, int eventid,
    void *arg, uint32_t flags)
{
    SRPT_DPRINTF_L3("stp_event_handler, invoked");
}

/*
 * srpt_stp_alloc_scsi_devid_desc()
 *
 * Allocate and initialize a SCSI device ID descriptor for
 * the SRP protocol.  Names are eui.GUID format.
 *
 * Both extension and guid are passed in host order.
 */
static scsi_devid_desc_t *
srpt_stp_alloc_scsi_devid_desc(uint64_t guid)
{
    scsi_devid_desc_t   *sdd;

    sdd = kmem_zalloc(sizeof (*sdd) + SRPT_EUI_ID_LEN + 1, KM_SLEEP);
    sdd->protocol_id = PROTOCOL_SRP;
    sdd->piv = 1;
    sdd->code_set = CODE_SET_ASCII;
    sdd->association = ID_IS_TARGET_PORT;
    sdd->ident_length = SRPT_EUI_ID_LEN;
    (void) sprintf((char *)sdd->ident, "eui.%016llX", (u_longlong_t)guid);
    return (sdd);
}

/*
 * srpt_stp_free_scsi_devid_desc()
 *
 * Free a SRPT SCSI device ID descriptor previously allocated via
 * srpt_stp_alloc_scsi_devid_desc().
 */
static void
srpt_stp_free_scsi_devid_desc(scsi_devid_desc_t *sdd)
{
    kmem_free(sdd, sizeof (*sdd) + SRPT_EUI_ID_LEN + 1);
}

/*
 * srpt_stp_alloc_session()
 */
srpt_session_t *
srpt_stp_alloc_session(srpt_target_port_t *tgt,
    uint8_t *i_id, uint8_t *t_id, uint8_t port,
    char *local_gid, char *remote_gid)
{
    stmf_status_t       status;
    srpt_session_t      *ss;
    stmf_scsi_session_t *stmf_ss;
    uint64_t        i_guid;
    scsi_srp_transport_id_t *srptpd;

    ASSERT(tgt != NULL);
    SRPT_DPRINTF_L3("stp_alloc_session, invoked");

    mutex_enter(&tgt->tp_sess_list_lock);

    i_guid = BE_IN64(&i_id[8]);

    stmf_ss = stmf_alloc(STMF_STRUCT_SCSI_SESSION,
        sizeof (srpt_session_t), 0);
    if (stmf_ss == NULL) {
        SRPT_DPRINTF_L2("stp_alloc_session, stmf_alloc"
            " returned NULL");
        mutex_exit(&tgt->tp_sess_list_lock);
        return (NULL);
    }
    ss = stmf_ss->ss_port_private;
    ASSERT(ss != NULL);

    rw_init(&ss->ss_rwlock, NULL, RW_DRIVER, NULL);
    list_create(&ss->ss_task_list, sizeof (srpt_iu_t),
        offsetof(srpt_iu_t, iu_ss_task_node));

    stmf_ss->ss_rport_id = srpt_stp_alloc_scsi_devid_desc(i_guid);
    /* Setup remote port transport id */
    stmf_ss->ss_rport = stmf_remote_port_alloc(
        sizeof (scsi_srp_transport_id_t));
    stmf_ss->ss_rport->rport_tptid->protocol_id = PROTOCOL_SRP;
    stmf_ss->ss_rport->rport_tptid->format_code = 0;
    srptpd = (scsi_srp_transport_id_t *)stmf_ss->ss_rport->rport_tptid;
    bcopy(i_id, srptpd->srp_name, SRP_PORT_ID_LEN);

    stmf_ss->ss_lport    = tgt->tp_lport;

    ss->ss_ss   = stmf_ss;
    ss->ss_hw_port  = port;
    ss->ss_tgt  = tgt;
    bcopy(i_id, ss->ss_i_id, SRP_PORT_ID_LEN);
    bcopy(t_id, ss->ss_t_id, SRP_PORT_ID_LEN);

    /*
     * Set the alias to include the initiator extension, this will enable
     * the administrator to identify multiple unique sessions originating
     * from the same initiator.
     */
    (void) strlcpy(ss->ss_i_gid, remote_gid, SRPT_ALIAS_LEN);
    (void) strlcpy(ss->ss_t_gid, local_gid, SRPT_ALIAS_LEN);
    EUI_STR(ss->ss_i_name, BE_IN64(&ss->ss_i_id[8]));
    EUI_STR(ss->ss_t_name, BE_IN64(&ss->ss_t_id[0]));
    ALIAS_STR(ss->ss_i_alias, BE_IN64(&ss->ss_i_id[0]),
        BE_IN64(&ss->ss_i_id[8]));
    ALIAS_STR(ss->ss_t_alias, BE_IN64(&ss->ss_t_id[0]),
        BE_IN64(&ss->ss_t_id[8]));
    stmf_ss->ss_rport_alias = ss->ss_i_alias;

    status = stmf_register_scsi_session(tgt->tp_lport, stmf_ss);
    if (status != STMF_SUCCESS) {
        SRPT_DPRINTF_L1("stp_alloc_session, STMF register session"
            " err(0x%llx)", (u_longlong_t)status);
        list_destroy(&ss->ss_task_list);
        rw_destroy(&ss->ss_rwlock);
        srpt_stp_free_scsi_devid_desc(stmf_ss->ss_rport_id);
        stmf_remote_port_free(stmf_ss->ss_rport);
        stmf_free(stmf_ss);
        mutex_exit(&tgt->tp_sess_list_lock);
        return (NULL);
    }

    list_insert_tail(&tgt->tp_sess_list, ss);
    mutex_exit(&tgt->tp_sess_list_lock);
    return (ss);
}

/*
 * srpt_stp_free_session()
 */
void
srpt_stp_free_session(srpt_session_t *session)
{
    stmf_scsi_session_t *stmf_ss;
    srpt_target_port_t  *tgt;

    ASSERT(session != NULL);

    tgt = session->ss_tgt;

    ASSERT(tgt != NULL);

    SRPT_DPRINTF_L3("stp_free_session, invoked");

    mutex_enter(&tgt->tp_sess_list_lock);

    stmf_ss = session->ss_ss;

    list_destroy(&session->ss_task_list);
    rw_destroy(&session->ss_rwlock);

    stmf_deregister_scsi_session(tgt->tp_lport, stmf_ss);
    srpt_stp_free_scsi_devid_desc(stmf_ss->ss_rport_id);
    stmf_remote_port_free(stmf_ss->ss_rport);
    list_remove(&tgt->tp_sess_list, session);
    cv_signal(&tgt->tp_sess_complete);
    mutex_exit(&tgt->tp_sess_list_lock);
    stmf_free(stmf_ss);
}

/*
 * srpt_stp_login() - SRP SCSI Target port login
 */
srpt_channel_t *
srpt_stp_login(srpt_target_port_t *tgt, srp_login_req_t *login,
    srp_login_rsp_t *login_rsp, srp_login_rej_t *login_rej,
    uint8_t login_port, char *local_gid, char *remote_gid)
{
    uint32_t    reason;
    uint32_t    req_it_ui_len;
    uint8_t     rsp_flags;
    srpt_ioc_t  *ioc;
    srpt_channel_t  *ch = NULL;
    srpt_channel_t  *next_ch = NULL;
    srpt_session_t  *session = NULL;
    srpt_session_t  sess;

    ASSERT(tgt != NULL);
    ASSERT(login != NULL);
    ASSERT(login_rsp != NULL);
    ASSERT(login_rej != NULL);

    /* Store the string representation of connection info */
    /* for Dtrace probes */
    bzero(&sess, sizeof (srpt_session_t));
    (void) strlcpy(sess.ss_i_gid, remote_gid, SRPT_ALIAS_LEN);
    (void) strlcpy(sess.ss_t_gid, local_gid, SRPT_ALIAS_LEN);
    EUI_STR(sess.ss_i_name,
        BE_IN64(&login->lreq_initiator_port_id[8]));
    EUI_STR(sess.ss_t_name,
        BE_IN64(&login->lreq_target_port_id[0]));
    ALIAS_STR(sess.ss_i_alias,
        BE_IN64(&login->lreq_initiator_port_id[0]),
        BE_IN64(&login->lreq_initiator_port_id[8]));
    ALIAS_STR(sess.ss_t_alias,
        BE_IN64(&login->lreq_target_port_id[0]),
        BE_IN64(&login->lreq_target_port_id[8]));

    DTRACE_SRP_2(login__command, srpt_session_t, &sess,
        srp_login_req_t, login);

    /*
     * The target lock taken here serializes logins to this target
     * and prevents an STMF target port from starting a control
     * operation to transition the target state while a login is
     * being processed.
     */
    bzero(login_rsp, sizeof (srp_login_rsp_t));
    bzero(login_rej, sizeof (srp_login_rej_t));
    mutex_enter(&tgt->tp_lock);
    ioc = tgt->tp_ioc;
    if (ioc == NULL) {
        SRPT_DPRINTF_L1("stp_login, NULL I/O Controller");
        reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
        goto reject_login;
    }

    /*
     * Validate that the SRP Target ID in the login request specifies
     * this I/O Controller SCSI Target Port.
     */
    if (memcmp(login->lreq_target_port_id, tgt->tp_srp_port_id,
        SRP_PORT_ID_LEN) != 0) {
        SRPT_DPRINTF_L2("stp_login, SRP CM SVC target ID mismatch."
            " Incoming TgtID 0x%016llx:0x%016llx",
            (u_longlong_t)BE_IN64(&login->lreq_target_port_id[0]),
            (u_longlong_t)BE_IN64(&login->lreq_target_port_id[8]));

        reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
        goto reject_login;
    }

    if (tgt->tp_state != SRPT_TGT_STATE_ONLINE) {
        SRPT_DPRINTF_L2("stp_login, SRP Login target not on-line");
        reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
        goto reject_login;
    }

    /*
     * Initiator requested IU size must be as large as the specification
     * minimum and no greater than what we chose to support.
     */
    req_it_ui_len = b2h32(login->lreq_req_it_iu_len);
    SRPT_DPRINTF_L2("stp_login, requested iu size = %d", req_it_ui_len);
    if (req_it_ui_len > srpt_iu_size) {
        SRPT_DPRINTF_L2("stp_login, SRP Login IU size (%d) too large",
            req_it_ui_len);
        reason = SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE;
        goto reject_login;
    }
    if (req_it_ui_len < SRP_MIN_IU_SIZE) {
        SRPT_DPRINTF_L2("stp_login, SRP Login IU size (%d) too small",
            req_it_ui_len);
        reason = SRP_LOGIN_REJ_NO_REASON;
        goto reject_login;
    }

    SRPT_DPRINTF_L2("stp_login, login req InitID 0x%016llx:0x%016llx",
        (u_longlong_t)BE_IN64(&login->lreq_initiator_port_id[0]),
        (u_longlong_t)BE_IN64(&login->lreq_initiator_port_id[8]));
    SRPT_DPRINTF_L2("stp_login, login req TgtID 0x%016llx:0x%016llx",
        (u_longlong_t)BE_IN64(&login->lreq_target_port_id[0]),
        (u_longlong_t)BE_IN64(&login->lreq_target_port_id[8]));

    /*
     * Processing is based on either single channel or multi-channel
     * operation.  In single channel, all current logins for this
     * same I_T_Nexus should be logged out.  In multi-channel
     * mode we would add an additional channel to an existing
     * I_T_Nexus if one currently exists (i.e. reference the
     * same SCSI session).
     */
    rsp_flags = SRP_MULTI_CH_RESULT_NO_EXISTING;

    switch (login->lreq_req_flags & SRP_LOGIN_MULTI_CH_MASK) {

    case SRP_LOGIN_MULTI_CH_SINGLE:
        /*
         * Only a single channel may be associated with a I_T_Nexus.
         * Disconnect any channel with the same SRP Initiator and
         * SRP target IDs.
         */
        mutex_enter(&tgt->tp_ch_list_lock);
        ch = list_head(&tgt->tp_ch_list);
        while (ch != NULL) {
            SRPT_DPRINTF_L3("stp_login, compare session,"
                " ch_state(%d)", ch->ch_state);
            next_ch = list_next(&tgt->tp_ch_list, ch);

            if (ch->ch_state != SRPT_CHANNEL_CONNECTING &&
                ch->ch_state != SRPT_CHANNEL_CONNECTED) {
                SRPT_DPRINTF_L3("stp_login, compare session,"
                    " channel not active");
                ch = next_ch;
                continue;
            }

            ASSERT(ch->ch_session != NULL);
            SRPT_DPRINTF_L3("stp_login, compare session"
                " I_ID 0x%016llx:0x%016llx",
                (u_longlong_t)b2h64(*((uint64_t *)(void *)
                &ch->ch_session->ss_i_id[0])),
                (u_longlong_t)b2h64(*((uint64_t *)(void *)
                &ch->ch_session->ss_i_id[8])));
            SRPT_DPRINTF_L3("stp_login, compare session"
                " T_ID 0x%016llx:0x%016llx",
                (u_longlong_t)b2h64(*((uint64_t *)(void *)
                &ch->ch_session->ss_t_id[0])),
                (u_longlong_t)b2h64(*((uint64_t *)(void *)
                &ch->ch_session->ss_t_id[8])));
            if ((bcmp(login->lreq_initiator_port_id,
                ch->ch_session->ss_i_id,
                SRP_PORT_ID_LEN) == 0) &&
                (bcmp(login->lreq_target_port_id,
                ch->ch_session->ss_t_id,
                SRP_PORT_ID_LEN) == 0)) {
                /*
                 * if a session is in the process of connecting,
                 * reject subsequent equivalent requests.
                 */
                if (ch->ch_state == SRPT_CHANNEL_CONNECTING) {
                    reason = SRP_LOGIN_REJ_INIT_CH_LIMIT;
                    mutex_exit(&tgt->tp_ch_list_lock);
                    goto reject_login;
                }

                SRPT_DPRINTF_L2("stp_login, terminate"
                    " existing login");
                rsp_flags =
                    SRP_MULTI_CH_RESULT_TERM_EXISTING;
                srpt_ch_disconnect(ch);
            }

            ch = next_ch;
        }
        mutex_exit(&tgt->tp_ch_list_lock);

        /* Create the new session for this SRP login */
        session = srpt_stp_alloc_session(tgt,
            login->lreq_initiator_port_id,
            login->lreq_target_port_id, login_port,
            local_gid, remote_gid);
        if (session == NULL) {
            SRPT_DPRINTF_L2("stp_login, session allocation"
                " failed");
            reason = SRP_LOGIN_REJ_UNABLE_TO_ASSOCIATE_I_T_NEXUS;
            goto reject_login;
        }
        break;

    case SRP_LOGIN_MULTI_CH_MULTIPLE:
        SRPT_DPRINTF_L2("stp_login, multichannel not supported yet");
        reason = SRP_LOGIN_REJ_MULTI_CH_NOT_SUPPORTED;
        goto reject_login;
        /* break via goto */

    default:
        SRPT_DPRINTF_L2("stp_login, invalid multichannel field (%d)",
            login->lreq_req_flags & SRP_LOGIN_MULTI_CH_MASK);
        reason = SRP_LOGIN_REJ_NO_REASON;
        goto reject_login;
        /* break via goto */
    }

    /*
     * Create new RDMA channel for this SRP login request.
     * The channel is returned with a single reference which
     * represents the reference held by the CM.
     */
    ch = srpt_ch_alloc(tgt, login_port);
    if (ch == NULL) {
        SRPT_DPRINTF_L2("stp_login, unable to alloc RDMA channel");
        reason = SRP_LOGIN_REJ_INSUFFICIENT_CH_RESOURCES;
        srpt_stp_free_session(session);
        goto reject_login;
    }
    ch->ch_session = session;
    ch->ch_ti_iu_len = b2h32(login->lreq_req_it_iu_len);

    /*
     * Add another reference to the channel which represents
     * a reference placed by the target port and add it to
     * the store of channels logged in for this target port.
     */
    srpt_ch_add_ref(ch);
    mutex_enter(&tgt->tp_ch_list_lock);
    list_insert_tail(&tgt->tp_ch_list, ch);
    mutex_exit(&tgt->tp_ch_list_lock);

    srpt_format_login_rsp(login, login_rsp, rsp_flags);
    mutex_exit(&tgt->tp_lock);
    SRPT_DPRINTF_L2("stp_login, login successful");

    DTRACE_SRP_3(login__response, srpt_session_t, &sess,
        srp_login_rsp_t, login_rsp, srp_login_rej_t, login_rej)

    return (ch);

reject_login:
    srpt_format_login_rej(login, login_rej, reason);
    mutex_exit(&tgt->tp_lock);

    DTRACE_SRP_3(login__response, srpt_session_t, &sess,
        srp_login_rsp_t, login_rsp, srp_login_rej_t, login_rej);

    return (NULL);
}

/*
 * srpt_stp_logout() - SRP logout
 *
 * Logout is not normally initiated in-band, but is so, just
 * initiate a disconnect.
 */
void
srpt_stp_logout(srpt_channel_t *ch)
{
    DTRACE_SRP_1(logout__command, srpt_channel_t, ch);
    SRPT_DPRINTF_L2("stp_logout, invoked for ch (%p)", (void *)ch);
    srpt_ch_disconnect(ch);
}

/*
 * srpt_format_login_rej() - Format login reject IU
 */
static void
srpt_format_login_rej(srp_login_req_t *req, srp_login_rej_t *rej,
    uint32_t reason)
{
    rej->lrej_type   = SRP_IU_LOGIN_REJ;
    rej->lrej_reason = h2b32(reason);
    rej->lrej_tag    = req->lreq_tag;
    rej->lrej_sup_buf_format =
        h2b16(SRP_DIRECT_BUFR_DESC | SRP_INDIRECT_BUFR_DESC);
}

/*
 * srpt_format_login_rsp() - Format login response IU
 */
static void
srpt_format_login_rsp(srp_login_req_t *req, srp_login_rsp_t *rsp,
    uint8_t flags)
{
    rsp->lrsp_type   = SRP_IU_LOGIN_RSP;
    rsp->lrsp_req_limit_delta = h2b32((uint32_t)srpt_send_msg_depth);
    rsp->lrsp_tag    = req->lreq_tag;

    rsp->lrsp_max_it_iu_len = req->lreq_req_it_iu_len;
    /* by def. > min T_IU_LEN */
    rsp->lrsp_max_ti_iu_len = req->lreq_req_it_iu_len;

    rsp->lrsp_sup_buf_format =
        h2b16(SRP_DIRECT_BUFR_DESC | SRP_INDIRECT_BUFR_DESC);
    rsp->lrsp_rsp_flags = flags;
}

/*
 * srpt_stp_add_task()
 */
void
srpt_stp_add_task(srpt_session_t *session, srpt_iu_t *iu)
{
    rw_enter(&session->ss_rwlock, RW_WRITER);
    list_insert_tail(&session->ss_task_list, iu);
    rw_exit(&session->ss_rwlock);
}

/*
 * srpt_stp_remove_task()
 */
void
srpt_stp_remove_task(srpt_session_t *session, srpt_iu_t *iu)
{
    rw_enter(&session->ss_rwlock, RW_WRITER);

    ASSERT(!list_is_empty(&session->ss_task_list));

    list_remove(&session->ss_task_list, iu);
    rw_exit(&session->ss_rwlock);
}