/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

#include <sys/cpuvar.h>

#include <sys/conf.h>

#include <sys/file.h>

#include <sys/ddi.h>

#include <sys/sunddi.h>

#include <sys/modctl.h>

#include <sys/socket.h>

#include <sys/strsubr.h>

#include <sys/sysmacros.h>

#include <sys/socketvar.h>

#include <netinet/in.h>

#include <sys/idm/idm.h>

#include <sys/idm/idm_so.h>

#define	IDM_NAME_VERSION	"iSCSI Data Mover"

extern struct mod_ops mod_miscops;

extern struct mod_ops mod_miscops;

static struct modlmisc modlmisc = {

	&mod_miscops,	/* Type of module */

	IDM_NAME_VERSION

};

static struct modlinkage modlinkage = {

	MODREV_1, (void *)&modlmisc, NULL

};

extern int idm_task_compare(const void *t1, const void *t2);

extern void idm_wd_thread(void *arg);

static int _idm_init(void);

static int _idm_fini(void);

static void idm_buf_bind_in_locked(idm_task_t *idt, idm_buf_t *buf);

static void idm_buf_bind_out_locked(idm_task_t *idt, idm_buf_t *buf);

static void idm_buf_unbind_in_locked(idm_task_t *idt, idm_buf_t *buf);

static void idm_buf_unbind_out_locked(idm_task_t *idt, idm_buf_t *buf);

static void idm_task_abort_one(idm_conn_t *ic, idm_task_t *idt,

    idm_abort_type_t abort_type);

static void idm_task_aborted(idm_task_t *idt, idm_status_t status);

boolean_t idm_conn_logging = 0;

boolean_t idm_svc_logging = 0;

/*

 * Potential tuneable for the maximum number of tasks.  Default to

 * IDM_TASKIDS_MAX

 */

uint32_t	idm_max_taskids = IDM_TASKIDS_MAX;

/*

 * Global list of transport handles

 *   These are listed in preferential order, so we can simply take the

 *   first "it_conn_is_capable" hit. Note also that the order maps to

 *   the order of the idm_transport_type_t list.

 */

idm_transport_t idm_transport_list[] = {

	/* iSER on InfiniBand transport handle */

	{IDM_TRANSPORT_TYPE_ISER,	/* type */

	"/devices/ib/iser@0:iser",	/* device path */

	NULL,				/* LDI handle */

	NULL,				/* transport ops */

	NULL},				/* transport caps */

	/* IDM native sockets transport handle */

	{IDM_TRANSPORT_TYPE_SOCKETS,	/* type */

	NULL,				/* device path */

	NULL,				/* LDI handle */

	NULL,				/* transport ops */

	NULL}				/* transport caps */

};

int

_init(void)

{

	int rc;

	if ((rc = _idm_init()) != 0) {

		return (rc);

	}

	return (mod_install(&modlinkage));

}

int

_fini(void)

{

	int rc;

	if ((rc = _idm_fini()) != 0) {

		return (rc);

	}

	if ((rc = mod_remove(&modlinkage)) != 0) {

		return (rc);

	}

	return (rc);

}

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

/*

 * idm_transport_register()

 *

 * Provides a mechanism for an IDM transport driver to register its

 * transport ops and caps with the IDM kernel module. Invoked during

 * a transport driver's attach routine.

 */

idm_status_t

idm_transport_register(idm_transport_attr_t *attr)

{

	ASSERT(attr->it_ops != NULL);

	ASSERT(attr->it_caps != NULL);

	switch (attr->type) {

	/* All known non-native transports here; for now, iSER */

	case IDM_TRANSPORT_TYPE_ISER:

		idm_transport_list[attr->type].it_ops	= attr->it_ops;

		idm_transport_list[attr->type].it_caps	= attr->it_caps;

		return (IDM_STATUS_SUCCESS);

	default:

		cmn_err(CE_NOTE, "idm: unknown transport type (0x%x) in "

		    "idm_transport_register", attr->type);

		return (IDM_STATUS_SUCCESS);

	}

}

/*

 * idm_ini_conn_create

 *

 * This function is invoked by the iSCSI layer to create a connection context.

 * This does not actually establish the socket connection.

 *

 * cr - Connection request parameters

 * new_con - Output parameter that contains the new request if successful

 *

 */

idm_status_t

idm_ini_conn_create(idm_conn_req_t *cr, idm_conn_t **new_con)

{

	idm_transport_t		*it;

	idm_conn_t		*ic;

	int			rc;

	it = idm_transport_lookup(cr);

retry:

	ic = idm_conn_create_common(CONN_TYPE_INI, it->it_type,

	    &cr->icr_conn_ops);

	bcopy(&cr->cr_ini_dst_addr, &ic->ic_ini_dst_addr,

	    sizeof (cr->cr_ini_dst_addr));

	/* create the transport-specific connection components */

	rc = it->it_ops->it_ini_conn_create(cr, ic);

	if (rc != IDM_STATUS_SUCCESS) {

		/* cleanup the failed connection */

		idm_conn_destroy_common(ic);

		kmem_free(ic, sizeof (idm_conn_t));

		/*

		 * It is possible for an IB client to connect to

		 * an ethernet-only client via an IB-eth gateway.

		 * Therefore, if we are attempting to use iSER and

		 * fail, retry with sockets before ultimately

		 * failing the connection.

		 */

		if (it->it_type == IDM_TRANSPORT_TYPE_ISER) {

			it = &idm_transport_list[IDM_TRANSPORT_TYPE_SOCKETS];

			goto retry;

		}

		return (IDM_STATUS_FAIL);

	}

	*new_con = ic;

	mutex_enter(&idm.idm_global_mutex);

	list_insert_tail(&idm.idm_ini_conn_list, ic);

	mutex_exit(&idm.idm_global_mutex);

	return (IDM_STATUS_SUCCESS);

}

/*

 * idm_ini_conn_destroy

 *

 * Releases any resources associated with the connection.  This is the

 * complement to idm_ini_conn_create.

 * ic - idm_conn_t structure representing the relevant connection

 *

 */

void

idm_ini_conn_destroy(idm_conn_t *ic)

{

	mutex_enter(&idm.idm_global_mutex);

	list_remove(&idm.idm_ini_conn_list, ic);

	mutex_exit(&idm.idm_global_mutex);

}

/*

 * idm_ini_conn_connect

 *

 * Establish connection to the remote system identified in idm_conn_t.

 * The connection parameters including the remote IP address were established

 *

 * ic - idm_conn_t structure representing the relevant connection

 *

 * Returns success if the connection was established, otherwise some kind

 * of meaningful error code.

 *

 */

idm_status_t

idm_ini_conn_connect(idm_conn_t *ic)

{

	rc = idm_conn_sm_init(ic);

	if (rc != IDM_STATUS_SUCCESS) {

		return (ic->ic_conn_sm_status);

	}

	/* Kick state machine */

	idm_conn_event(ic, CE_CONNECT_REQ, NULL);

	/* Wait for login flag */

	mutex_enter(&ic->ic_state_mutex);

	while (!(ic->ic_state_flags & CF_LOGIN_READY) &&

	    !(ic->ic_state_flags & CF_ERROR)) {

		cv_wait(&ic->ic_state_cv, &ic->ic_state_mutex);

	}

	mutex_exit(&ic->ic_state_mutex);

	if (ic->ic_state_flags & CF_ERROR) {

		/* ic->ic_conn_sm_status will contains failure status */

		return (ic->ic_conn_sm_status);

	}

	/* Ready to login */

	ASSERT(ic->ic_state_flags & CF_LOGIN_READY);

	(void) idm_notify_client(ic, CN_READY_FOR_LOGIN, NULL);

}

/*

 * idm_ini_conn_disconnect

 *

 * Forces a connection (previously established using idm_ini_conn_connect)

 * to perform a controlled shutdown, cleaning up any outstanding requests.

 *

 * ic - idm_conn_t structure representing the relevant connection

 *

 */

/* ARGSUSED */

void

idm_ini_conn_disconnect(idm_conn_t *ic)

{

	}

	mutex_exit(&ic->ic_state_mutex);

}

/*

 * idm_tgt_svc_create

 *

 * The target calls this service to obtain a service context for each available

 * transport, starting a service of each type related to the IP address and port

 * passed. The idm_svc_req_t contains the service parameters.

 */

idm_status_t

idm_tgt_svc_create(idm_svc_req_t *sr, idm_svc_t **new_svc)

{

	idm_transport_type_t	type;

	idm_transport_t		*it;

	idm_svc_t		*is;

	int			rc;

	*new_svc = NULL;

	is = kmem_zalloc(sizeof (idm_svc_t), KM_SLEEP);

	/* Initialize transport-agnostic components of the service handle */

	is->is_svc_req = *sr;

	mutex_init(&is->is_mutex, NULL, MUTEX_DEFAULT, NULL);

	cv_init(&is->is_cv, NULL, CV_DEFAULT, NULL);

	mutex_init(&is->is_count_mutex, NULL, MUTEX_DEFAULT, NULL);

	cv_init(&is->is_count_cv, NULL, CV_DEFAULT, NULL);

	idm_refcnt_init(&is->is_refcnt, is);

	/*

	 * Make sure all available transports are setup.  We call this now

	 * instead of at initialization time in case IB has become available

	 * since we started (hotplug, etc).

	 */

	idm_transport_setup(sr->sr_li);

	/*

	 * Loop through the transports, configuring the transport-specific

	 * components of each one.

	 */

	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {

		it = &idm_transport_list[type];

		/*

		 * If it_ops is NULL then the transport is unconfigured

		 * and we shouldn't try to start the service.

		 */

		if (it->it_ops == NULL) {

			continue;

		}

		rc = it->it_ops->it_tgt_svc_create(sr, is);

		if (rc != IDM_STATUS_SUCCESS) {

			/* Teardown any configured services */

			while (type--) {

				it = &idm_transport_list[type];

				if (it->it_ops == NULL) {

					continue;

				}

				it->it_ops->it_tgt_svc_destroy(is);

			}

			/* Free the svc context and return */

			kmem_free(is, sizeof (idm_svc_t));

			return (rc);

		}

	}

	*new_svc = is;

	mutex_enter(&idm.idm_global_mutex);

	list_insert_tail(&idm.idm_tgt_svc_list, is);

	mutex_exit(&idm.idm_global_mutex);

	return (IDM_STATUS_SUCCESS);

}

/*

 * idm_tgt_svc_destroy

 *

 * is - idm_svc_t returned by the call to idm_tgt_svc_create

 *

 * Cleanup any resources associated with the idm_svc_t.

 */

void

idm_tgt_svc_destroy(idm_svc_t *is)

{

	idm_transport_type_t	type;

	idm_transport_t		*it;

	mutex_enter(&idm.idm_global_mutex);

	/* remove this service from the global list */

	list_remove(&idm.idm_tgt_svc_list, is);

	/* wakeup any waiters for service change */

	cv_broadcast(&idm.idm_tgt_svc_cv);

	mutex_exit(&idm.idm_global_mutex);

	/* teardown each transport-specific service */

	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {

		it = &idm_transport_list[type];

		if (it->it_ops == NULL) {

			continue;

		}

		it->it_ops->it_tgt_svc_destroy(is);

	}

	/* free the svc handle */

	kmem_free(is, sizeof (idm_svc_t));

}

void

idm_tgt_svc_hold(idm_svc_t *is)

{

	idm_refcnt_hold(&is->is_refcnt);

}

void

idm_tgt_svc_rele_and_destroy(idm_svc_t *is)

{

	idm_refcnt_rele_and_destroy(&is->is_refcnt,

	    (idm_refcnt_cb_t *)&idm_tgt_svc_destroy);

}

/*

 * idm_tgt_svc_online

 *

 * is - idm_svc_t returned by the call to idm_tgt_svc_create

 *

 * Online each transport service, as we want this target to be accessible

 * via any configured transport.

 *

 * When the initiator establishes a new connection to the target, IDM will

 * call the "new connect" callback defined in the idm_svc_req_t structure

 * and it will pass an idm_conn_t structure representing that new connection.

 */

idm_status_t

idm_tgt_svc_online(idm_svc_t *is)

{

	idm_transport_t		*it;

	mutex_enter(&is->is_mutex);

	if (is->is_online == 0) {

		for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {

			it = &idm_transport_list[type];

			if (it->it_ops == NULL) {

				/* transport is not registered */

				continue;

			}