/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#include <sys/types.h>

#include <sys/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 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

 */

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		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.

				 */

				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 {

		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);

			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;

		ibt_deregister_service(iser_state->is_ibhdl,

		    iser_svc->is_srvhdl);

		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_rc_channel

 *

 * This function allocates a reliable communication channel using the specified

 * channel attributes.

 */

iser_chan_t *

iser_ib_alloc_rc_channel(ibt_ip_addr_t *local_ip, ibt_ip_addr_t *remote_ip)

{

	iser_chan_t			*chan;

	ib_gid_t			lgid;

	uint8_t				hca_port; /* from path */

	iser_hca_t			*hca;

	ibt_path_ip_src_t		path_src_ip;

	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_lock, NULL, MUTEX_DRIVER, NULL);

	mutex_init(&chan->ic_sq_post_lock, NULL, MUTEX_DRIVER, NULL);

	/* Lookup a path to the given destination */

	status = iser_ib_get_paths(local_ip, remote_ip, &chan->ic_ibt_path,

	    &path_src_ip);

	if (status != ISER_STATUS_SUCCESS) {

		ISER_LOG(CE_NOTE, "iser_ib_get_paths failed: status (%d)",

		    status);

		mutex_destroy(&chan->ic_lock);

		mutex_destroy(&chan->ic_sq_post_lock);

		kmem_free(chan, sizeof (iser_chan_t));

		return (NULL);

	}

	/* get the local gid from the path info */

	lgid = chan->ic_ibt_path.pi_prim_cep_path.cep_adds_vect.av_sgid;

	/* get the hca port from the path info */

	hca_port = chan->ic_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_rc_channel: failed "

		    "to lookup HCA handle");

		mutex_destroy(&chan->ic_lock);

		mutex_destroy(&chan->ic_sq_post_lock);

		kmem_free(chan, sizeof (iser_chan_t));

		return (NULL);

	}

	/* Set up the iSER channel handle with HCA and IP data */

	chan->ic_hca		= hca;

	chan->ic_localip	= path_src_ip.ip_primary;

	chan->ic_remoteip	= *remote_ip;

	/*

	 * 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_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);

	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_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);

	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_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);

	ISER_LOG(CE_NOTE, "iser_ib_alloc_rc_channel 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);

	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_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_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);