6940166 iSER assertion panic triggered when iSCSI discovery is activated on IB interface
6828570 setting a headerdigest or datadigest flag to an IB port causes the initiator to not see the LUN
/*
* 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.
*/
#include <sys/types.h>
#include <sys/ddi.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>
#include <sys/iscsi_protocol.h>
#include <sys/ib/clients/iser/iser.h>
#include <sys/ib/clients/iser/iser_idm.h>
/*
* iser_ib.c
* Routines for InfiniBand transport for iSER
*
* This file contains the routines to interface with the IBT API to attach and
* allocate IB resources, handle async events, and post recv work requests.
*
*/
static iser_hca_t *iser_ib_gid2hca(ib_gid_t gid);
static iser_hca_t *iser_ib_guid2hca(ib_guid_t guid);
static iser_hca_t *iser_ib_alloc_hca(ib_guid_t guid);
static int iser_ib_free_hca(iser_hca_t *hca);
static int iser_ib_update_hcaports(iser_hca_t *hca);
static int iser_ib_init_hcas(void);
static int iser_ib_fini_hcas(void);
static iser_sbind_t *iser_ib_get_bind(
iser_svc_t *iser_svc, ib_guid_t hca_guid, ib_gid_t gid);
static int iser_ib_activate_port(
idm_svc_t *idm_svc, ib_guid_t guid, ib_gid_t gid);
static void iser_ib_deactivate_port(ib_guid_t hca_guid, ib_gid_t gid);
static void iser_ib_init_qp(iser_chan_t *chan, uint_t sq_size, uint_t rq_size);
static void iser_ib_fini_qp(iser_qp_t *qp);
static int iser_ib_setup_cq(ibt_hca_hdl_t hca_hdl, uint_t cq_size,
ibt_cq_hdl_t *cq_hdl);
static void iser_ib_setup_chanargs(uint8_t hca_port, ibt_cq_hdl_t scq_hdl,
ibt_cq_hdl_t rcq_hdl, uint_t sq_size, uint_t rq_size,
ibt_pd_hdl_t hca_pdhdl, ibt_rc_chan_alloc_args_t *cargs);
static void iser_ib_handle_portup_event(ibt_hca_hdl_t hdl,
ibt_async_event_t *event);
static void iser_ib_handle_portdown_event(ibt_hca_hdl_t hdl,
ibt_async_event_t *event);
static void iser_ib_handle_hca_detach_event(ibt_hca_hdl_t hdl,
ibt_async_event_t *event);
static void iser_ib_post_recv_task(void *arg);
static struct ibt_clnt_modinfo_s iser_ib_modinfo = {
IBTI_V_CURR,
IBT_STORAGE_DEV,
iser_ib_async_handler,
NULL,
"iSER"
};
/*
* iser_ib_init
*
* This function registers the HCA drivers with IBTF and registers and binds
* iSER as a service with IBTF.
*/
int
iser_ib_init(void)
{
int status;
/* Register with IBTF */
status = ibt_attach(&iser_ib_modinfo, iser_state->is_dip, iser_state,
&iser_state->is_ibhdl);
if (status != DDI_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_init: ibt_attach failed (0x%x)",
status);
return (DDI_FAILURE);
}
/* Create the global work request kmem_cache */
iser_state->iser_wr_cache = kmem_cache_create("iser_wr_cache",
sizeof (iser_wr_t), 0, NULL, NULL, NULL,
iser_state, NULL, KM_SLEEP);
/* Populate our list of HCAs */
status = iser_ib_init_hcas();
if (status != DDI_SUCCESS) {
/* HCAs failed to initialize, tear it down */
kmem_cache_destroy(iser_state->iser_wr_cache);
(void) ibt_detach(iser_state->is_ibhdl);
iser_state->is_ibhdl = NULL;
ISER_LOG(CE_NOTE, "iser_ib_init: failed to initialize HCAs");
return (DDI_FAILURE);
}
/* Target will register iSER as a service with IBTF when required */
/* Target will bind this service when it comes online */
return (DDI_SUCCESS);
}
/*
* iser_ib_fini
*
* This function unbinds and degisters the iSER service from IBTF
*/
int
iser_ib_fini(void)
{
/* IDM would have already disabled all the services */
/* Teardown the HCA list and associated resources */
if (iser_ib_fini_hcas() != DDI_SUCCESS)
return (DDI_FAILURE);
/* Teardown the global work request kmem_cache */
kmem_cache_destroy(iser_state->iser_wr_cache);
/* Deregister with IBTF */
if (iser_state->is_ibhdl != NULL) {
(void) ibt_detach(iser_state->is_ibhdl);
iser_state->is_ibhdl = NULL;
}
return (DDI_SUCCESS);
}
/*
* iser_ib_register_service
*
* This function registers the iSER service using the RDMA-Aware Service ID.
*/
int
iser_ib_register_service(idm_svc_t *idm_svc)
{
ibt_srv_desc_t srvdesc;
iser_svc_t *iser_svc;
int status;
bzero(&srvdesc, sizeof (ibt_srv_desc_t));
/* Set up IBTI client callback handler from the CM */
srvdesc.sd_handler = iser_ib_cm_handler;
srvdesc.sd_flags = IBT_SRV_NO_FLAGS;
iser_svc = (iser_svc_t *)idm_svc->is_iser_svc;
/* Register the service on the specified port */
status = ibt_register_service(
iser_state->is_ibhdl, &srvdesc,
iser_svc->is_svcid, 1, &iser_svc->is_srvhdl, NULL);
return (status);
}
/*
* iser_ib_bind_service
*
* This function binds a given iSER service on all available HCA ports. The
* current specification does not allow user to specify transport bindings
* for each iscsi target. The ULP invokes this function to bind the target
* to all available iser ports after checking for the presence of an IB HCA.
* iSER is "configured" whenever an IB-capable IP address exists. The lack
* of active IB ports is a less-fatal condition, and sockets would be used
* as the transport even though an Infiniband HCA is configured but unusable.
*
*/
int
iser_ib_bind_service(idm_svc_t *idm_svc)
{
iser_hca_t *hca;
ib_gid_t gid;
int num_ports = 0;
int num_binds = 0;
int num_inactive_binds = 0; /* if HCA ports inactive */
int status;
int i;
ASSERT(idm_svc != NULL);
ASSERT(idm_svc->is_iser_svc != NULL);
/* Register the iSER service on all available ports */
mutex_enter(&iser_state->is_hcalist_lock);
for (hca = list_head(&iser_state->is_hcalist);
hca != NULL;
hca = list_next(&iser_state->is_hcalist, hca)) {
for (i = 0; i < hca->hca_num_ports; i++) {
num_ports++;
if (hca->hca_port_info[i].p_linkstate !=
IBT_PORT_ACTIVE) {
/*
* Move on. We will attempt to bind service
* in our async handler if the port comes up
* at a later time.
*/
num_inactive_binds++;
continue;
}
gid = hca->hca_port_info[i].p_sgid_tbl[0];
/* If the port is already bound, skip */
if (iser_ib_get_bind(
idm_svc->is_iser_svc, hca->hca_guid, gid) == NULL) {
status = iser_ib_activate_port(
idm_svc, hca->hca_guid, gid);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE,
"iser_ib_bind_service: "
"iser_ib_activate_port failure "
"(0x%x)", status);
continue;
}
}
num_binds++;
}
}
mutex_exit(&iser_state->is_hcalist_lock);
if (num_binds) {
ISER_LOG(CE_NOTE, "iser_ib_bind_service: Service available on "
"(%d) of (%d) ports", num_binds, num_ports);
return (ISER_STATUS_SUCCESS);
} else if (num_inactive_binds) {
ISER_LOG(CE_NOTE, "iser_ib_bind_service: Could not bind "
"service, HCA ports are not active.");
/*
* still considered success, the async handler will bind
* the service when the port comes up at a later time
*/
return (ISER_STATUS_SUCCESS);
} else {
ISER_LOG(CE_NOTE, "iser_ib_bind_service: Did not bind service");
return (ISER_STATUS_FAIL);
}
}
/*
* iser_ib_unbind_service
*
* This function unbinds a given service on a all HCA ports
*/
void
iser_ib_unbind_service(idm_svc_t *idm_svc)
{
iser_svc_t *iser_svc;
iser_sbind_t *is_sbind, *next_sb;
if (idm_svc != NULL && idm_svc->is_iser_svc != NULL) {
iser_svc = idm_svc->is_iser_svc;
for (is_sbind = list_head(&iser_svc->is_sbindlist);
is_sbind != NULL;
is_sbind = next_sb) {
next_sb = list_next(&iser_svc->is_sbindlist, is_sbind);
(void) ibt_unbind_service(iser_svc->is_srvhdl,
is_sbind->is_sbindhdl);
list_remove(&iser_svc->is_sbindlist, is_sbind);
kmem_free(is_sbind, sizeof (iser_sbind_t));
}
}
}
/* ARGSUSED */
void
iser_ib_deregister_service(idm_svc_t *idm_svc)
{
iser_svc_t *iser_svc;
if (idm_svc != NULL && idm_svc->is_iser_svc != NULL) {
iser_svc = (iser_svc_t *)idm_svc->is_iser_svc;
(void) ibt_deregister_service(iser_state->is_ibhdl,
iser_svc->is_srvhdl);
(void) ibt_release_ip_sid(iser_svc->is_svcid);
}
}
/*
* iser_ib_get_paths
* This function finds the IB path between the local and the remote address.
*
*/
int
iser_ib_get_paths(ibt_ip_addr_t *local_ip, ibt_ip_addr_t *remote_ip,
ibt_path_info_t *path, ibt_path_ip_src_t *path_src_ip)
{
ibt_ip_path_attr_t ipattr;
int status;
(void) bzero(&ipattr, sizeof (ibt_ip_path_attr_t));
ipattr.ipa_dst_ip = remote_ip;
ipattr.ipa_src_ip = *local_ip;
ipattr.ipa_max_paths = 1;
ipattr.ipa_ndst = 1;
(void) bzero(path, sizeof (ibt_path_info_t));
status = ibt_get_ip_paths(iser_state->is_ibhdl, IBT_PATH_NO_FLAGS,
&ipattr, path, NULL, path_src_ip);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "ibt_get_ip_paths: ibt_get_ip_paths "
"failure: status (%d)", status);
return (status);
}
if (local_ip != NULL) {
ISER_LOG(CE_NOTE, "iser_ib_get_paths success: IP[%x to %x]",
local_ip->un.ip4addr, remote_ip->un.ip4addr);
} else {
ISER_LOG(CE_NOTE, "iser_ib_get_paths success: "
"IP[INADDR_ANY to %x]", remote_ip->un.ip4addr);
}
return (ISER_STATUS_SUCCESS);
}
/*
* iser_ib_alloc_channel_nopathlookup
*
* This function allocates a reliable connected channel. This function does
* not invoke ibt_get_ip_paths() to do the path lookup. The HCA GUID and
* port are input to this function.
*/
iser_chan_t *
iser_ib_alloc_channel_nopathlookup(ib_guid_t hca_guid, uint8_t hca_port)
{
iser_hca_t *hca;
iser_chan_t *chan;
/* Lookup the hca using the gid in the path info */
hca = iser_ib_guid2hca(hca_guid);
if (hca == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_nopathlookup: failed "
"to lookup HCA(%llx) handle", (longlong_t)hca_guid);
return (NULL);
}
chan = iser_ib_alloc_rc_channel(hca, hca_port);
if (chan == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_nopathlookup: failed "
"to alloc channel on HCA(%llx) %d",
(longlong_t)hca_guid, hca_port);
return (NULL);
}
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_pathlookup success: "
"chanhdl (0x%p), HCA(%llx) %d",
(void *)chan->ic_chanhdl, (longlong_t)hca_guid, hca_port);
return (chan);
}
/*
* iser_ib_alloc_channel_pathlookup
*
* This function allocates a reliable connected channel but first invokes
* ibt_get_ip_paths() with the given local and remote addres to get the
* HCA lgid and the port number.
*/
iser_chan_t *
iser_ib_alloc_channel_pathlookup(
ibt_ip_addr_t *local_ip, ibt_ip_addr_t *remote_ip)
{
ibt_path_info_t ibt_path;
ibt_path_ip_src_t path_src_ip;
ib_gid_t lgid;
uint8_t hca_port; /* from path */
iser_hca_t *hca;
iser_chan_t *chan;
int status;
/* Lookup a path to the given destination */
status = iser_ib_get_paths(
local_ip, remote_ip, &ibt_path, &path_src_ip);
if (status != ISER_STATUS_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_pathlookup: faild "
"Path lookup IP:[%llx to %llx] failed: status (%d)",
(longlong_t)local_ip->un.ip4addr,
(longlong_t)remote_ip->un.ip4addr,
status);
return (NULL);
}
/* get the local gid from the path info */
lgid = ibt_path.pi_prim_cep_path.cep_adds_vect.av_sgid;
/* get the hca port from the path info */
hca_port = ibt_path.pi_prim_cep_path.cep_hca_port_num;
/* Lookup the hca using the gid in the path info */
hca = iser_ib_gid2hca(lgid);
if (hca == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_pathlookup: failed "
"to lookup HCA (%llx) handle",
(longlong_t)hca->hca_guid);
return (NULL);
}
chan = iser_ib_alloc_rc_channel(hca, hca_port);
if (chan == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_pathlookup: failed "
"to alloc channel from IP:[%llx to %llx] on HCA (%llx) %d",
(longlong_t)local_ip->un.ip4addr,
(longlong_t)remote_ip->un.ip4addr,
(longlong_t)hca->hca_guid, hca_port);
return (NULL);
}
ISER_LOG(CE_NOTE, "iser_ib_alloc_channel_pathlookup success: "
"chanhdl (0x%p), IP:[%llx to %llx], lgid (%llx:%llx), HCA(%llx) %d",
(void *)chan->ic_chanhdl,
(longlong_t)local_ip->un.ip4addr,
(longlong_t)remote_ip->un.ip4addr,
(longlong_t)lgid.gid_prefix, (longlong_t)lgid.gid_guid,
(longlong_t)hca->hca_guid, hca_port);
chan->ic_ibt_path = ibt_path;
chan->ic_localip = path_src_ip.ip_primary;
chan->ic_remoteip = *remote_ip;
return (chan);
}
/*
* iser_ib_alloc_rc_channel
*
* This function allocates a reliable communication channel using the specified
* channel attributes.
*/
iser_chan_t *
iser_ib_alloc_rc_channel(iser_hca_t *hca, uint8_t hca_port)
{
iser_chan_t *chan;
ibt_rc_chan_alloc_args_t chanargs;
uint_t sq_size, rq_size;
int status;
chan = kmem_zalloc(sizeof (iser_chan_t), KM_SLEEP);
mutex_init(&chan->ic_chan_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&chan->ic_sq_post_lock, NULL, MUTEX_DRIVER, NULL);
/* Set up the iSER channel handle with HCA */
chan->ic_hca = hca;
/*
* Determine the queue sizes, based upon the HCA query data.
* For our Work Queues, we will use either our default value,
* or the HCA's maximum value, whichever is smaller.
*/
sq_size = min(hca->hca_attr.hca_max_chan_sz, ISER_IB_SENDQ_SIZE);
rq_size = min(hca->hca_attr.hca_max_chan_sz, ISER_IB_RECVQ_SIZE);
/*
* For our Completion Queues, we again check the device maximum.
* We want to end up with CQs that are the next size up from the
* WQs they are servicing so that they have some overhead.
*/
if (hca->hca_attr.hca_max_cq_sz >= (sq_size + 1)) {
chan->ic_sendcq_sz = sq_size + 1;
} else {
chan->ic_sendcq_sz = hca->hca_attr.hca_max_cq_sz;
sq_size = chan->ic_sendcq_sz - 1;
}
if (hca->hca_attr.hca_max_cq_sz >= (rq_size + 1)) {
chan->ic_recvcq_sz = rq_size + 1;
} else {
chan->ic_recvcq_sz = hca->hca_attr.hca_max_cq_sz;
rq_size = chan->ic_recvcq_sz - 1;
}
/* Initialize the iSER channel's QP handle */
iser_ib_init_qp(chan, sq_size, rq_size);
/* Set up the Send Completion Queue */
status = iser_ib_setup_cq(hca->hca_hdl, chan->ic_sendcq_sz,
&chan->ic_sendcq);
if (status != ISER_STATUS_SUCCESS) {
iser_ib_fini_qp(&chan->ic_qp);
mutex_destroy(&chan->ic_chan_lock);
mutex_destroy(&chan->ic_sq_post_lock);
kmem_free(chan, sizeof (iser_chan_t));
return (NULL);
}
ibt_set_cq_handler(chan->ic_sendcq, iser_ib_sendcq_handler, chan);
(void) ibt_enable_cq_notify(chan->ic_sendcq, IBT_NEXT_COMPLETION);
/* Set up the Receive Completion Queue */
status = iser_ib_setup_cq(hca->hca_hdl, chan->ic_recvcq_sz,
&chan->ic_recvcq);
if (status != ISER_STATUS_SUCCESS) {
(void) ibt_free_cq(chan->ic_sendcq);
iser_ib_fini_qp(&chan->ic_qp);
mutex_destroy(&chan->ic_chan_lock);
mutex_destroy(&chan->ic_sq_post_lock);
kmem_free(chan, sizeof (iser_chan_t));
return (NULL);
}
ibt_set_cq_handler(chan->ic_recvcq, iser_ib_recvcq_handler, chan);
(void) ibt_enable_cq_notify(chan->ic_recvcq, IBT_NEXT_COMPLETION);
/* Setup the channel arguments */
iser_ib_setup_chanargs(hca_port, chan->ic_sendcq, chan->ic_recvcq,
sq_size, rq_size, hca->hca_pdhdl, &chanargs);
status = ibt_alloc_rc_channel(hca->hca_hdl,
IBT_ACHAN_NO_FLAGS, &chanargs, &chan->ic_chanhdl, NULL);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_rc_channel: failed "
"ibt_alloc_rc_channel: status (%d)", status);
(void) ibt_free_cq(chan->ic_sendcq);
(void) ibt_free_cq(chan->ic_recvcq);
iser_ib_fini_qp(&chan->ic_qp);
mutex_destroy(&chan->ic_chan_lock);
mutex_destroy(&chan->ic_sq_post_lock);
kmem_free(chan, sizeof (iser_chan_t));
return (NULL);
}
/* Set the 'channel' as the client private data */
(void) ibt_set_chan_private(chan->ic_chanhdl, chan);
return (chan);
}
/*
* iser_ib_open_rc_channel
* This function opens a RC connection on the given allocated RC channel
*/
int
iser_ib_open_rc_channel(iser_chan_t *chan)
{
ibt_ip_cm_info_t ipcm_info;
iser_private_data_t iser_priv_data;
ibt_chan_open_args_t ocargs;
ibt_rc_returns_t ocreturns;
int status;
mutex_enter(&chan->ic_chan_lock);
/*
* For connection establishment, the initiator sends a CM REQ using the
* iSER RDMA-Aware Service ID. Included are the source and destination
* IP addresses, and the src port.
*/
bzero(&ipcm_info, sizeof (ibt_ip_cm_info_t));
ipcm_info.src_addr = chan->ic_localip;
ipcm_info.dst_addr = chan->ic_remoteip;
ipcm_info.src_port = chan->ic_lport;
/*
* The CM Private Data field defines the iSER connection parameters
* such as zero based virtual address exception (ZBVAE) and Send with
* invalidate Exception (SIE).
*
* Solaris IBT does not currently support ZBVAE or SIE.
*/
iser_priv_data.rsvd1 = 0;
iser_priv_data.sie = 1;
iser_priv_data.zbvae = 1;
status = ibt_format_ip_private_data(&ipcm_info,
sizeof (iser_private_data_t), &iser_priv_data);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_open_rc_channel failed: %d", status);
mutex_exit(&chan->ic_chan_lock);
return (status);
}
/*
* Set the SID we are attempting to connect to, based upon the
* remote port number.
*/
chan->ic_ibt_path.pi_sid = ibt_get_ip_sid(IPPROTO_TCP, chan->ic_rport);
/* Set up the args for the channel open */
bzero(&ocargs, sizeof (ibt_chan_open_args_t));
ocargs.oc_path = &chan->ic_ibt_path;
ocargs.oc_cm_handler = iser_ib_cm_handler;
ocargs.oc_cm_clnt_private = iser_state;
ocargs.oc_rdma_ra_out = 4;
ocargs.oc_rdma_ra_in = 4;
ocargs.oc_path_retry_cnt = 2;
ocargs.oc_path_rnr_retry_cnt = 2;
ocargs.oc_priv_data_len = sizeof (iser_private_data_t);
ocargs.oc_priv_data = &iser_priv_data;
bzero(&ocreturns, sizeof (ibt_rc_returns_t));
status = ibt_open_rc_channel(chan->ic_chanhdl,
IBT_OCHAN_NO_FLAGS, IBT_BLOCKING, &ocargs, &ocreturns);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_open_rc_channel failed: %d", status);
mutex_exit(&chan->ic_chan_lock);
return (status);
}
mutex_exit(&chan->ic_chan_lock);
return (IDM_STATUS_SUCCESS);
}
/*
* iser_ib_close_rc_channel
* This function closes the RC channel related to this iser_chan handle.
* We invoke this in a non-blocking, no callbacks context.
*/
void
iser_ib_close_rc_channel(iser_chan_t *chan)
{
int status;
mutex_enter(&chan->ic_chan_lock);
status = ibt_close_rc_channel(chan->ic_chanhdl, IBT_BLOCKING, NULL,
0, NULL, NULL, 0);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_close_rc_channel: "
"ibt_close_rc_channel failed: status (%d)", status);
}
mutex_exit(&chan->ic_chan_lock);
}
/*
* iser_ib_free_rc_channel
*
* This function tears down an RC channel's QP initialization and frees it.
* Note that we do not need synchronization here; the channel has been
* closed already, so we should only have completion polling occuring. Once
* complete, we are free to free the IBTF channel, WQ and CQ resources, and
* our own related resources.
*/
void
iser_ib_free_rc_channel(iser_chan_t *chan)
{
iser_qp_t *iser_qp;
iser_qp = &chan->ic_qp;
/* Ensure the SQ is empty */
while (chan->ic_sq_post_count != 0) {
mutex_exit(&chan->ic_conn->ic_lock);
delay(drv_usectohz(ISER_DELAY_HALF_SECOND));
mutex_enter(&chan->ic_conn->ic_lock);
}
mutex_destroy(&chan->ic_sq_post_lock);
/* Ensure the RQ is empty */
(void) ibt_flush_channel(chan->ic_chanhdl);
mutex_enter(&iser_qp->qp_lock);
while (iser_qp->rq_level != 0) {
mutex_exit(&iser_qp->qp_lock);
mutex_exit(&chan->ic_conn->ic_lock);
delay(drv_usectohz(ISER_DELAY_HALF_SECOND));
mutex_enter(&chan->ic_conn->ic_lock);
mutex_enter(&iser_qp->qp_lock);
}
/* Free our QP handle */
mutex_exit(&iser_qp->qp_lock);
(void) iser_ib_fini_qp(iser_qp);
/* Free the IBT channel resources */
(void) ibt_free_channel(chan->ic_chanhdl);
chan->ic_chanhdl = NULL;
/* Free the CQs */
(void) ibt_free_cq(chan->ic_sendcq);
(void) ibt_free_cq(chan->ic_recvcq);
/* Free the chan handle */
mutex_destroy(&chan->ic_chan_lock);
kmem_free(chan, sizeof (iser_chan_t));
}
/*
* iser_ib_post_recv
*
* This function handles keeping the RQ full on a given channel.
* This routine will mostly be run on a taskq, and will check the
* current fill level of the RQ, and post as many WRs as necessary
* to fill it again.
*/
int
iser_ib_post_recv_async(ibt_channel_hdl_t chanhdl)
{
iser_chan_t *chan;
int status;
/* Pull our iSER channel handle from the private data */
chan = (iser_chan_t *)ibt_get_chan_private(chanhdl);
/*
* Caller must check that chan->ic_conn->ic_stage indicates
* the connection is active (not closing, not closed) and
* it must hold the mutex cross the check and the call to this function
*/
ASSERT(mutex_owned(&chan->ic_conn->ic_lock));
ASSERT((chan->ic_conn->ic_stage >= ISER_CONN_STAGE_ALLOCATED) &&
(chan->ic_conn->ic_stage <= ISER_CONN_STAGE_LOGGED_IN));
idm_conn_hold(chan->ic_conn->ic_idmc);
status = ddi_taskq_dispatch(iser_taskq, iser_ib_post_recv_task,
(void *)chanhdl, DDI_NOSLEEP);
if (status != DDI_SUCCESS) {
idm_conn_rele(chan->ic_conn->ic_idmc);
}
return (status);
}
static void
iser_ib_post_recv_task(void *arg)
{
ibt_channel_hdl_t chanhdl = arg;
iser_chan_t *chan;
/* Pull our iSER channel handle from the private data */
chan = (iser_chan_t *)ibt_get_chan_private(chanhdl);
iser_ib_post_recv(chanhdl);
idm_conn_rele(chan->ic_conn->ic_idmc);
}
void
iser_ib_post_recv(ibt_channel_hdl_t chanhdl)
{
iser_chan_t *chan;
iser_hca_t *hca;
iser_msg_t *msg;
ibt_recv_wr_t *wrlist, wr[ISER_IB_RQ_POST_MAX];
int rq_space, msg_ret;
int total_num, npost;
uint_t nposted;
int status, i;
iser_qp_t *iser_qp;
/* Pull our iSER channel handle from the private data */
chan = (iser_chan_t *)ibt_get_chan_private(chanhdl);
ASSERT(chan != NULL);
mutex_enter(&chan->ic_conn->ic_lock);
/* Bail out if the connection is closed; no need for more recv WRs */
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;
}
/* get the QP handle from the iser_chan */
iser_qp = &chan->ic_qp;
hca = chan->ic_hca;
if (hca == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: unable to retrieve "
"HCA handle");
mutex_exit(&chan->ic_conn->ic_lock);
return;
}
/* check for space to post on the RQ */
mutex_enter(&iser_qp->qp_lock);
rq_space = iser_qp->rq_depth - iser_qp->rq_level;
if (rq_space == 0) {
/* The RQ is full, clear the pending flag and return */
iser_qp->rq_taskqpending = B_FALSE;
mutex_exit(&iser_qp->qp_lock);
mutex_exit(&chan->ic_conn->ic_lock);
return;
}
/* Keep track of the lowest value for rq_min_post_level */
if (iser_qp->rq_level < iser_qp->rq_min_post_level)
iser_qp->rq_min_post_level = iser_qp->rq_level;
mutex_exit(&iser_qp->qp_lock);
/* we've room to post, so pull from the msg cache */
msg = iser_msg_get(hca, rq_space, &msg_ret);
if (msg == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: no message handles "
"available in msg cache currently");
/*
* There are no messages on the cache. Wait a half-
* second, then try again.
*/
delay(drv_usectohz(ISER_DELAY_HALF_SECOND));
status = iser_ib_post_recv_async(chanhdl);
if (status != DDI_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: failed to "
"redispatch routine");
/* Failed to dispatch, clear pending flag */
mutex_enter(&iser_qp->qp_lock);
iser_qp->rq_taskqpending = B_FALSE;
mutex_exit(&iser_qp->qp_lock);
}
mutex_exit(&chan->ic_conn->ic_lock);
return;
}
if (msg_ret != rq_space) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: requested number of "
"messages not allocated: requested (%d) allocated (%d)",
rq_space, msg_ret);
/* We got some, but not all, of our requested depth */
rq_space = msg_ret;
}
/*
* Now, walk through the allocated WRs and post them,
* ISER_IB_RQ_POST_MAX (or less) at a time.
*/
wrlist = &wr[0];
total_num = rq_space;
while (total_num) {
/* determine the number to post on this iteration */
npost = (total_num > ISER_IB_RQ_POST_MAX) ?
ISER_IB_RQ_POST_MAX : total_num;
/* build a list of WRs from the msg list */
for (i = 0; i < npost; i++) {
wrlist[i].wr_id = (ibt_wrid_t)(uintptr_t)msg;
wrlist[i].wr_nds = ISER_IB_SGLIST_SIZE;
wrlist[i].wr_sgl = &msg->msg_ds;
msg = msg->nextp;
}
/* post the list to the RQ */
nposted = 0;
status = ibt_post_recv(chanhdl, wrlist, npost, &nposted);
if ((status != IBT_SUCCESS) || (nposted != npost)) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: ibt_post_recv "
"failed: requested (%d) posted (%d) status (%d)",
npost, nposted, status);
total_num -= nposted;
break;
}
/* decrement total number to post by the number posted */
total_num -= nposted;
}
mutex_enter(&iser_qp->qp_lock);
if (total_num != 0) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: unable to fill RQ, "
"failed to post (%d) WRs", total_num);
iser_qp->rq_level += rq_space - total_num;
} else {
iser_qp->rq_level += rq_space;
}
/*
* Now that we've filled the RQ, check that all of the recv WRs
* haven't just been immediately consumed. If so, taskqpending is
* still B_TRUE, so we need to fire off a taskq thread to post
* more WRs.
*/
if (iser_qp->rq_level == 0) {
mutex_exit(&iser_qp->qp_lock);
status = iser_ib_post_recv_async(chanhdl);
if (status != DDI_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_post_recv: failed to "
"dispatch followup routine");
/* Failed to dispatch, clear pending flag */
mutex_enter(&iser_qp->qp_lock);
iser_qp->rq_taskqpending = B_FALSE;
mutex_exit(&iser_qp->qp_lock);
}
} else {
/*
* We're done, we've filled the RQ. Clear the taskq
* flag so that we can run again.
*/
iser_qp->rq_taskqpending = B_FALSE;
mutex_exit(&iser_qp->qp_lock);
}
mutex_exit(&chan->ic_conn->ic_lock);
}
/*
* iser_ib_handle_portup_event()
* This handles the IBT_EVENT_PORT_UP unaffiliated asynchronous event.
*
* To facilitate a seamless bringover of the port and configure the CM service
* for inbound iSER service requests on this newly active port, the existing
* IDM services will be checked for iSER support.
* If an iSER service was already created, then this service will simply be
* bound to the gid of the newly active port. If on the other hand, the CM
* service did not exist, i.e. only socket communication, then a new CM
* service will be first registered with the saved service parameters and
* then bound to the newly active port.
*
*/
/* ARGSUSED */
static void
iser_ib_handle_portup_event(ibt_hca_hdl_t hdl, ibt_async_event_t *event)
{
iser_hca_t *hca;
ib_gid_t gid;
idm_svc_t *idm_svc;
int status;
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event: HCA(0x%llx) port(%d)",
(longlong_t)event->ev_hca_guid, event->ev_port);
/*
* Query all ports on the HCA and update the port information
* maintainted in the iser_hca_t structure
*/
hca = iser_ib_guid2hca(event->ev_hca_guid);
if (hca == NULL) {
/* HCA is just made available, first port on that HCA */
hca = iser_ib_alloc_hca(event->ev_hca_guid);
if (hca == NULL) {
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event "
"iser_ib_alloc_hca failed: HCA(0x%llx) port(%d)",
(longlong_t)event->ev_hca_guid, event->ev_port);
return;
}
mutex_enter(&iser_state->is_hcalist_lock);
list_insert_tail(&iser_state->is_hcalist, hca);
iser_state->is_num_hcas++;
mutex_exit(&iser_state->is_hcalist_lock);
} else {
status = iser_ib_update_hcaports(hca);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event "
"status(0x%x): iser_ib_update_hcaports failed: "
"HCA(0x%llx) port(%d)", status,
(longlong_t)event->ev_hca_guid, event->ev_port);
return;
}
}
gid = hca->hca_port_info[event->ev_port - 1].p_sgid_tbl[0];
/*
* Iterate through the global list of IDM target services
* and check for existing iSER CM service.
*/
mutex_enter(&idm.idm_global_mutex);
for (idm_svc = list_head(&idm.idm_tgt_svc_list);
idm_svc != NULL;
idm_svc = list_next(&idm.idm_tgt_svc_list, idm_svc)) {
if (idm_svc->is_iser_svc == NULL) {
/* Establish a new CM service for iSER requests */
status = iser_tgt_svc_create(
&idm_svc->is_svc_req, idm_svc);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event "
"status(0x%x): iser_tgt_svc_create failed: "
"HCA(0x%llx) port(%d)", status,
(longlong_t)event->ev_hca_guid,
event->ev_port);
continue;
}
}
status = iser_ib_activate_port(
idm_svc, event->ev_hca_guid, gid);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event "
"status(0x%x): Bind service on port "
"(%llx:%llx) failed",
status, (longlong_t)gid.gid_prefix,
(longlong_t)gid.gid_guid);
continue;
}
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event: service bound "
"HCA(0x%llx) port(%d)", (longlong_t)event->ev_hca_guid,
event->ev_port);
}
mutex_exit(&idm.idm_global_mutex);
ISER_LOG(CE_NOTE, "iser_ib_handle_portup_event success: "
"HCA(0x%llx) port(%d)", (longlong_t)event->ev_hca_guid,
event->ev_port);
}
/*
* iser_ib_handle_portdown_event()
* This handles the IBT_EVENT_PORT_DOWN unaffiliated asynchronous error.
*
* Unconfigure the CM service on the deactivated port and teardown the
* connections that are using the CM service.
*/
/* ARGSUSED */
static void
iser_ib_handle_portdown_event(ibt_hca_hdl_t hdl, ibt_async_event_t *event)
{
iser_hca_t *hca;
ib_gid_t gid;
int status;
/*
* Query all ports on the HCA and update the port information
* maintainted in the iser_hca_t structure
*/
hca = iser_ib_guid2hca(event->ev_hca_guid);
ASSERT(hca != NULL);
status = iser_ib_update_hcaports(hca);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_handle_portdown_event status(0x%x): "
"ibt_ib_update_hcaports failed: HCA(0x%llx) port(%d)",
status, (longlong_t)event->ev_hca_guid, event->ev_port);
return;
}
/* get the gid of the new port */
gid = hca->hca_port_info[event->ev_port - 1].p_sgid_tbl[0];
iser_ib_deactivate_port(event->ev_hca_guid, gid);
ISER_LOG(CE_NOTE, "iser_ib_handle_portdown_event success: "
"HCA(0x%llx) port(%d)", (longlong_t)event->ev_hca_guid,
event->ev_port);
}
/*
* iser_ib_handle_hca_detach_event()
* Quiesce all activity bound for the port, teardown the connection, unbind
* iSER services on all ports and release the HCA handle.
*/
/* ARGSUSED */
static void
iser_ib_handle_hca_detach_event(ibt_hca_hdl_t hdl, ibt_async_event_t *event)
{
iser_hca_t *nexthca, *hca;
int i, status;
ISER_LOG(CE_NOTE, "iser_ib_handle_hca_detach_event: HCA(0x%llx)",
(longlong_t)event->ev_hca_guid);
hca = iser_ib_guid2hca(event->ev_hca_guid);
for (i = 0; i < hca->hca_num_ports; i++) {
iser_ib_deactivate_port(hca->hca_guid,
hca->hca_port_info[i].p_sgid_tbl[0]);
}
/*
* Update the HCA list maintained in the iser_state. Free the
* resources allocated to the HCA, i.e. caches, protection domain
*/
mutex_enter(&iser_state->is_hcalist_lock);
for (hca = list_head(&iser_state->is_hcalist);
hca != NULL;
hca = nexthca) {
nexthca = list_next(&iser_state->is_hcalist, hca);
if (hca->hca_guid == event->ev_hca_guid) {
list_remove(&iser_state->is_hcalist, hca);
iser_state->is_num_hcas--;
status = iser_ib_free_hca(hca);
if (status != DDI_SUCCESS) {
ISER_LOG(CE_WARN, "iser_ib_handle_hca_detach: "
"Failed to free hca(%p)", (void *)hca);
list_insert_tail(&iser_state->is_hcalist, hca);
iser_state->is_num_hcas++;
}
/* No way to return status to IBT if this fails */
}
}
mutex_exit(&iser_state->is_hcalist_lock);
}
/*
* iser_ib_async_handler
* An IBT Asynchronous Event handler is registered it with the framework and
* passed via the ibt_attach() routine. This function handles the following
* asynchronous events.
* IBT_EVENT_PORT_UP
* IBT_ERROR_PORT_DOWN
* IBT_HCA_ATTACH_EVENT
* IBT_HCA_DETACH_EVENT
*/
/* ARGSUSED */
void
iser_ib_async_handler(void *clntp, ibt_hca_hdl_t hdl, ibt_async_code_t code,
ibt_async_event_t *event)
{
switch (code) {
case IBT_EVENT_PORT_UP:
iser_ib_handle_portup_event(hdl, event);
break;
case IBT_ERROR_PORT_DOWN:
iser_ib_handle_portdown_event(hdl, event);
break;
case IBT_HCA_ATTACH_EVENT:
/*
* A new HCA device is available for use, ignore this
* event because the corresponding IBT_EVENT_PORT_UP
* events will get triggered and handled accordingly.
*/
break;
case IBT_HCA_DETACH_EVENT:
iser_ib_handle_hca_detach_event(hdl, event);
break;
default:
break;
}
}
/*
* iser_ib_init_hcas
*
* This function opens all the HCA devices, gathers the HCA state information
* and adds the HCA handle for each HCA found in the iser_soft_state.
*/
static int
iser_ib_init_hcas(void)
{
ib_guid_t *guid;
int num_hcas;
int i;
iser_hca_t *hca;
/* Retrieve the HCA list */
num_hcas = ibt_get_hca_list(&guid);
if (num_hcas == 0) {
/*
* This shouldn't happen, but might if we have all HCAs
* detach prior to initialization.
*/
return (DDI_FAILURE);
}
/* Initialize the hcalist lock */
mutex_init(&iser_state->is_hcalist_lock, NULL, MUTEX_DRIVER, NULL);
/* Create the HCA list */
list_create(&iser_state->is_hcalist, sizeof (iser_hca_t),
offsetof(iser_hca_t, hca_node));
for (i = 0; i < num_hcas; i++) {
ISER_LOG(CE_NOTE, "iser_ib_init_hcas: initializing HCA "
"(0x%llx)", (longlong_t)guid[i]);
hca = iser_ib_alloc_hca(guid[i]);
if (hca == NULL) {
/* This shouldn't happen, teardown and fail */
(void) iser_ib_fini_hcas();
(void) ibt_free_hca_list(guid, num_hcas);
return (DDI_FAILURE);
}
mutex_enter(&iser_state->is_hcalist_lock);
list_insert_tail(&iser_state->is_hcalist, hca);
iser_state->is_num_hcas++;
mutex_exit(&iser_state->is_hcalist_lock);
}
/* Free the IBT HCA list */
(void) ibt_free_hca_list(guid, num_hcas);
/* Check that we've initialized at least one HCA */
mutex_enter(&iser_state->is_hcalist_lock);
if (list_is_empty(&iser_state->is_hcalist)) {
ISER_LOG(CE_NOTE, "iser_ib_init_hcas: failed to initialize "
"any HCAs");
mutex_exit(&iser_state->is_hcalist_lock);
(void) iser_ib_fini_hcas();
return (DDI_FAILURE);
}
mutex_exit(&iser_state->is_hcalist_lock);
return (DDI_SUCCESS);
}
/*
* iser_ib_fini_hcas
*
* Teardown the iSER HCA list initialized above.
*/
static int
iser_ib_fini_hcas(void)
{
iser_hca_t *nexthca, *hca;
int status;
mutex_enter(&iser_state->is_hcalist_lock);
for (hca = list_head(&iser_state->is_hcalist);
hca != NULL;
hca = nexthca) {
nexthca = list_next(&iser_state->is_hcalist, hca);
list_remove(&iser_state->is_hcalist, hca);
status = iser_ib_free_hca(hca);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_fini_hcas: failed to free "
"HCA during fini");
list_insert_tail(&iser_state->is_hcalist, hca);
return (DDI_FAILURE);
}
iser_state->is_num_hcas--;
}
mutex_exit(&iser_state->is_hcalist_lock);
list_destroy(&iser_state->is_hcalist);
mutex_destroy(&iser_state->is_hcalist_lock);
return (DDI_SUCCESS);
}
/*
* iser_ib_alloc_hca
*
* This function opens the given HCA device, gathers the HCA state information
* and adds the HCA handle
*/
static iser_hca_t *
iser_ib_alloc_hca(ib_guid_t guid)
{
iser_hca_t *hca;
int status;
/* Allocate an iser_hca_t HCA handle */
hca = (iser_hca_t *)kmem_zalloc(sizeof (iser_hca_t), KM_SLEEP);
/* Open this HCA */
status = ibt_open_hca(iser_state->is_ibhdl, guid, &hca->hca_hdl);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_hca: ibt_open_hca failed:"
" guid (0x%llx) status (0x%x)", (longlong_t)guid, status);
kmem_free(hca, sizeof (iser_hca_t));
return (NULL);
}
hca->hca_guid = guid;
hca->hca_clnt_hdl = iser_state->is_ibhdl;
/* Query the HCA */
status = ibt_query_hca(hca->hca_hdl, &hca->hca_attr);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_hca: ibt_query_hca "
"failure: guid (0x%llx) status (0x%x)",
(longlong_t)guid, status);
(void) ibt_close_hca(hca->hca_hdl);
kmem_free(hca, sizeof (iser_hca_t));
return (NULL);
}
/* Query all ports on the HCA */
status = ibt_query_hca_ports(hca->hca_hdl, 0,
&hca->hca_port_info, &hca->hca_num_ports,
&hca->hca_port_info_sz);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_hca: "
"ibt_query_hca_ports failure: guid (0x%llx) "
"status (0x%x)", (longlong_t)guid, status);
(void) ibt_close_hca(hca->hca_hdl);
kmem_free(hca, sizeof (iser_hca_t));
return (NULL);
}
/* Allocate a single PD on this HCA */
status = ibt_alloc_pd(hca->hca_hdl, IBT_PD_NO_FLAGS,
&hca->hca_pdhdl);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_alloc_hca: ibt_alloc_pd "
"failure: guid (0x%llx) status (0x%x)",
(longlong_t)guid, status);
(void) ibt_close_hca(hca->hca_hdl);
ibt_free_portinfo(hca->hca_port_info, hca->hca_port_info_sz);
kmem_free(hca, sizeof (iser_hca_t));
return (NULL);
}
/* Initialize the message and data MR caches for this HCA */
iser_init_hca_caches(hca);
return (hca);
}
static int
iser_ib_free_hca(iser_hca_t *hca)
{
int status;
ibt_hca_portinfo_t *hca_port_info;
uint_t hca_port_info_sz;
ASSERT(hca != NULL);
if (hca->hca_failed)
return (DDI_FAILURE);
hca_port_info = hca->hca_port_info;
hca_port_info_sz = hca->hca_port_info_sz;
/*
* Free the memory regions before freeing
* the associated protection domain
*/
iser_fini_hca_caches(hca);
status = ibt_free_pd(hca->hca_hdl, hca->hca_pdhdl);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_free_hca: failed to free PD "
"status=0x%x", status);
goto out_caches;
}
status = ibt_close_hca(hca->hca_hdl);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_fini_hcas: failed to close HCA "
"status=0x%x", status);
goto out_pd;
}
ibt_free_portinfo(hca_port_info, hca_port_info_sz);
kmem_free(hca, sizeof (iser_hca_t));
return (DDI_SUCCESS);
/*
* We only managed to partially tear down the HCA, try to put it back
* like it was before returning.
*/
out_pd:
status = ibt_alloc_pd(hca->hca_hdl, IBT_PD_NO_FLAGS, &hca->hca_pdhdl);
if (status != IBT_SUCCESS) {
hca->hca_failed = B_TRUE;
/* Report error and exit */
ISER_LOG(CE_NOTE, "iser_ib_free_hca: could not re-alloc PD "
"status=0x%x", status);
return (DDI_FAILURE);
}
out_caches:
iser_init_hca_caches(hca);
return (DDI_FAILURE);
}
static int
iser_ib_update_hcaports(iser_hca_t *hca)
{
ibt_hca_portinfo_t *pinfop, *oldpinfop;
uint_t size, oldsize, nport;
int status;
ASSERT(hca != NULL);
status = ibt_query_hca_ports(hca->hca_hdl, 0, &pinfop, &nport, &size);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "ibt_query_hca_ports failed: %d", status);
return (status);
}
oldpinfop = hca->hca_port_info;
oldsize = hca->hca_port_info_sz;
hca->hca_port_info = pinfop;
hca->hca_port_info_sz = size;
(void) ibt_free_portinfo(oldpinfop, oldsize);
return (IBT_SUCCESS);
}
/*
* iser_ib_gid2hca
* Given a gid, find the corresponding hca
*/
iser_hca_t *
iser_ib_gid2hca(ib_gid_t gid)
{
iser_hca_t *hca;
int i;
mutex_enter(&iser_state->is_hcalist_lock);
for (hca = list_head(&iser_state->is_hcalist);
hca != NULL;
hca = list_next(&iser_state->is_hcalist, hca)) {
for (i = 0; i < hca->hca_num_ports; i++) {
if ((hca->hca_port_info[i].p_sgid_tbl[0].gid_prefix ==
gid.gid_prefix) &&
(hca->hca_port_info[i].p_sgid_tbl[0].gid_guid ==
gid.gid_guid)) {
mutex_exit(&iser_state->is_hcalist_lock);
return (hca);
}
}
}
mutex_exit(&iser_state->is_hcalist_lock);
return (NULL);
}
/*
* iser_ib_guid2hca
* Given a HCA guid, find the corresponding HCA
*/
iser_hca_t *
iser_ib_guid2hca(ib_guid_t guid)
{
iser_hca_t *hca;
mutex_enter(&iser_state->is_hcalist_lock);
for (hca = list_head(&iser_state->is_hcalist);
hca != NULL;
hca = list_next(&iser_state->is_hcalist, hca)) {
if (hca->hca_guid == guid) {
mutex_exit(&iser_state->is_hcalist_lock);
return (hca);
}
}
mutex_exit(&iser_state->is_hcalist_lock);
return (NULL);
}
/*
* iser_ib_conv_sockaddr2ibtaddr
* This function converts a socket address into the IBT format
*/
void iser_ib_conv_sockaddr2ibtaddr(
idm_sockaddr_t *saddr, ibt_ip_addr_t *ibt_addr)
{
if (saddr == NULL) {
ibt_addr->family = AF_UNSPEC;
ibt_addr->un.ip4addr = 0;
} else {
switch (saddr->sin.sa_family) {
case AF_INET:
ibt_addr->family = saddr->sin4.sin_family;
ibt_addr->un.ip4addr = saddr->sin4.sin_addr.s_addr;
break;
case AF_INET6:
ibt_addr->family = saddr->sin6.sin6_family;
ibt_addr->un.ip6addr = saddr->sin6.sin6_addr;
break;
default:
ibt_addr->family = AF_UNSPEC;
}
}
}
/*
* iser_ib_conv_ibtaddr2sockaddr
* This function converts an IBT ip address handle to a sockaddr
*/
void iser_ib_conv_ibtaddr2sockaddr(struct sockaddr_storage *ss,
ibt_ip_addr_t *ibt_addr, in_port_t port)
{
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
switch (ibt_addr->family) {
case AF_INET:
case AF_UNSPEC:
sin = (struct sockaddr_in *)ibt_addr;
sin->sin_port = ntohs(port);
bcopy(sin, ss, sizeof (struct sockaddr_in));
break;
case AF_INET6:
sin6 = (struct sockaddr_in6 *)ibt_addr;
sin6->sin6_port = ntohs(port);
bcopy(sin6, ss, sizeof (struct sockaddr_in6));
break;
default:
ISER_LOG(CE_NOTE, "iser_ib_conv_ibtaddr2sockaddr: "
"unknown family type: 0x%x", ibt_addr->family);
}
}
/*
* iser_ib_setup_cq
* This function sets up the Completion Queue size and allocates the specified
* Completion Queue
*/
static int
iser_ib_setup_cq(ibt_hca_hdl_t hca_hdl, uint_t cq_size, ibt_cq_hdl_t *cq_hdl)
{
ibt_cq_attr_t cq_attr;
int status;
cq_attr.cq_size = cq_size;
cq_attr.cq_sched = 0;
cq_attr.cq_flags = IBT_CQ_NO_FLAGS;
/* Allocate a Completion Queue */
status = ibt_alloc_cq(hca_hdl, &cq_attr, cq_hdl, NULL);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_setup_cq: ibt_alloc_cq failure (%d)",
status);
return (status);
}
return (ISER_STATUS_SUCCESS);
}
/*
* iser_ib_setup_chanargs
*
*/
static void
iser_ib_setup_chanargs(uint8_t hca_port, ibt_cq_hdl_t scq_hdl,
ibt_cq_hdl_t rcq_hdl, uint_t sq_size, uint_t rq_size,
ibt_pd_hdl_t hca_pdhdl, ibt_rc_chan_alloc_args_t *cargs)
{
bzero(cargs, sizeof (ibt_rc_chan_alloc_args_t));
/*
* Set up the size of the channels send queue, receive queue and the
* maximum number of elements in a scatter gather list of work requests
* posted to the send and receive queues.
*/
cargs->rc_sizes.cs_sq = sq_size;
cargs->rc_sizes.cs_rq = rq_size;
cargs->rc_sizes.cs_sq_sgl = ISER_IB_SGLIST_SIZE;
cargs->rc_sizes.cs_rq_sgl = ISER_IB_SGLIST_SIZE;
/*
* All Work requests signaled on a WR basis will receive a send
* request completion.
*/
cargs->rc_flags = IBT_ALL_SIGNALED;
/* Enable RDMA read and RDMA write on the channel end points */
cargs->rc_control = IBT_CEP_RDMA_RD | IBT_CEP_RDMA_WR;
/* Set the local hca port on which the channel is allocated */
cargs->rc_hca_port_num = hca_port;
/* Set the Send and Receive Completion Queue handles */
cargs->rc_scq = scq_hdl;
cargs->rc_rcq = rcq_hdl;
/* Set the protection domain associated with the channel */
cargs->rc_pd = hca_pdhdl;
/* No SRQ usage */
cargs->rc_srq = NULL;
}
/*
* iser_ib_init_qp
* Initialize the QP handle
*/
void
iser_ib_init_qp(iser_chan_t *chan, uint_t sq_size, uint_t rq_size)
{
/* Initialize the handle lock */
mutex_init(&chan->ic_qp.qp_lock, NULL, MUTEX_DRIVER, NULL);
/* Record queue sizes */
chan->ic_qp.sq_size = sq_size;
chan->ic_qp.rq_size = rq_size;
/* Initialize the RQ monitoring data */
chan->ic_qp.rq_depth = rq_size;
chan->ic_qp.rq_level = 0;
chan->ic_qp.rq_lwm = (chan->ic_recvcq_sz * ISER_IB_RQ_LWM_PCT) / 100;
/* Initialize the taskq flag */
chan->ic_qp.rq_taskqpending = B_FALSE;
}
/*
* iser_ib_fini_qp
* Teardown the QP handle
*/
void
iser_ib_fini_qp(iser_qp_t *qp)
{
/* Destroy the handle lock */
mutex_destroy(&qp->qp_lock);
}
static int
iser_ib_activate_port(idm_svc_t *idm_svc, ib_guid_t guid, ib_gid_t gid)
{
iser_svc_t *iser_svc;
iser_sbind_t *is_sbind;
int status;
iser_svc = idm_svc->is_iser_svc;
/*
* Save the address of the service bind handle in the
* iser_svc_t to undo the service binding at a later time
*/
is_sbind = kmem_zalloc(sizeof (iser_sbind_t), KM_SLEEP);
is_sbind->is_gid = gid;
is_sbind->is_guid = guid;
status = ibt_bind_service(iser_svc->is_srvhdl, gid, NULL,
idm_svc, &is_sbind->is_sbindhdl);
if (status != IBT_SUCCESS) {
ISER_LOG(CE_NOTE, "iser_ib_activate_port: status(0x%x): "
"Bind service(%llx) on port(%llx:%llx) failed",
status, (longlong_t)iser_svc->is_svcid,
(longlong_t)gid.gid_prefix, (longlong_t)gid.gid_guid);
kmem_free(is_sbind, sizeof (iser_sbind_t));
return (status);
}
list_insert_tail(&iser_svc->is_sbindlist, is_sbind);
return (IBT_SUCCESS);
}
static void
iser_ib_deactivate_port(ib_guid_t hca_guid, ib_gid_t gid)
{
iser_svc_t *iser_svc;
iser_conn_t *iser_conn;
iser_sbind_t *is_sbind;
idm_conn_t *idm_conn;
/*
* Iterate through the global list of IDM target connections.
* Issue a TRANSPORT_FAIL for any connections on this port, and
* if there is a bound service running on the port, tear it down.
*/
mutex_enter(&idm.idm_global_mutex);
for (idm_conn = list_head(&idm.idm_tgt_conn_list);
idm_conn != NULL;
idm_conn = list_next(&idm.idm_tgt_conn_list, idm_conn)) {
if (idm_conn->ic_transport_type != IDM_TRANSPORT_TYPE_ISER) {
/* this is not an iSER connection, skip it */
continue;
}
iser_conn = idm_conn->ic_transport_private;
if (iser_conn->ic_chan->ic_ibt_path.pi_hca_guid != hca_guid) {
/* this iSER connection is on a different port */
continue;
}
/* Fail the transport for this connection */
idm_conn_event(idm_conn, CE_TRANSPORT_FAIL, IDM_STATUS_FAIL);
if (idm_conn->ic_conn_type == CONN_TYPE_INI) {
/* initiator connection, nothing else to do */
continue;
}
/* Check for a service binding */
iser_svc = idm_conn->ic_svc_binding->is_iser_svc;
is_sbind = iser_ib_get_bind(iser_svc, hca_guid, gid);
if (is_sbind != NULL) {
/* This service is still bound, tear it down */
(void) ibt_unbind_service(iser_svc->is_srvhdl,
is_sbind->is_sbindhdl);
list_remove(&iser_svc->is_sbindlist, is_sbind);
kmem_free(is_sbind, sizeof (iser_sbind_t));
}
}
mutex_exit(&idm.idm_global_mutex);
}
static iser_sbind_t *
iser_ib_get_bind(iser_svc_t *iser_svc, ib_guid_t hca_guid, ib_gid_t gid)
{
iser_sbind_t *is_sbind;
for (is_sbind = list_head(&iser_svc->is_sbindlist);
is_sbind != NULL;
is_sbind = list_next(&iser_svc->is_sbindlist, is_sbind)) {
if ((is_sbind->is_guid == hca_guid) &&
(is_sbind->is_gid.gid_prefix == gid.gid_prefix) &&
(is_sbind->is_gid.gid_guid == gid.gid_guid)) {
return (is_sbind);
}
}
return (NULL);
}