xref: /illumos-gate/usr/src/uts/common/io/scsi/adapters/iscsi/iscsi.c (revision 61dfa509)

/*
 * 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 2000 by Cisco Systems, Inc.  All rights reserved.
 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
 * Copyright 2019 Joshua M. Clulow <josh@sysmgr.org>
 *
 * iSCSI Software Initiator
 */

/*
 * Framework interface routines for iSCSI
 */

#include "iscsi.h"				/* main header */
#include <sys/iscsi_protocol.h>	/* protocol structs */
#include <sys/scsi/adapters/iscsi_if.h>		/* ioctl interfaces */
#include "iscsi_targetparam.h"
#include "persistent.h"
#include <sys/scsi/adapters/iscsi_door.h>
#include <sys/dlpi.h>
#include <sys/utsname.h>
#include "isns_client.h"
#include "isns_protocol.h"
#include <sys/bootprops.h>
#include <sys/types.h>
#include <sys/bootconf.h>

#define	ISCSI_NAME_VERSION	"iSCSI Initiator v-1.55"

#define	MAX_GET_NAME_SIZE	1024
#define	MAX_NAME_PROP_SIZE	256
#define	UNDEFINED		-1
#define	ISCSI_DISC_DELAY	2	/* seconds */

/*
 * +--------------------------------------------------------------------+
 * | iscsi globals                                                      |
 * +--------------------------------------------------------------------+
 */
void		*iscsi_state;
kmutex_t	iscsi_oid_mutex;
uint32_t	iscsi_oid;
int		iscsi_nop_delay		= ISCSI_DEFAULT_NOP_DELAY;
int		iscsi_rx_window		= ISCSI_DEFAULT_RX_WINDOW;
int		iscsi_rx_max_window	= ISCSI_DEFAULT_RX_MAX_WINDOW;
boolean_t	iscsi_logging		= B_FALSE;

extern ib_boot_prop_t	*iscsiboot_prop;
extern int		modrootloaded;
extern struct bootobj	rootfs;

/*
 * +--------------------------------------------------------------------+
 * | iscsi.c prototypes							|
 * +--------------------------------------------------------------------+
 */
static int iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
    void *arg, void **result);
static int iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);

/* scsi_tran prototypes */
static int iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
static int iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ());
static struct scsi_pkt *iscsi_tran_init_pkt(struct scsi_address *ap,
    struct scsi_pkt *pkt, struct buf *bp, int cmdlen, int statuslen,
    int tgtlen, int flags, int (*callback) (), caddr_t arg);
static void iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
static int iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt);
static int iscsi_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt);
static int iscsi_tran_reset(struct scsi_address *ap, int level);
static int iscsi_tran_getcap(struct scsi_address *ap, char *cap, int whom);
static int iscsi_tran_setcap(struct scsi_address *ap, char *cap,
    int value, int whom);
static void iscsi_tran_destroy_pkt(struct scsi_address *ap,
    struct scsi_pkt *pkt);
static void iscsi_tran_dmafree(struct scsi_address *ap,
    struct scsi_pkt *pkt);
static void iscsi_tran_sync_pkt(struct scsi_address *ap,
    struct scsi_pkt *pkt);
static void iscsi_tran_sync_pkt(struct scsi_address *ap,
    struct scsi_pkt *pkt);
static int iscsi_tran_reset_notify(struct scsi_address *ap, int flag,
    void (*callback) (caddr_t), caddr_t arg);
static int iscsi_tran_bus_config(dev_info_t *parent, uint_t flags,
    ddi_bus_config_op_t op, void *arg, dev_info_t **childp);
static int iscsi_tran_bus_unconfig(dev_info_t *parent, uint_t flags,
    ddi_bus_config_op_t op, void *arg);
static int iscsi_tran_get_name(struct scsi_device *sd, char *name, int len);
static int iscsi_tran_get_bus_addr(struct scsi_device *sd, char *name, int len);

/* bus_ops prototypes */
/* LINTED E_STATIC_UNUSED */
static ddi_intrspec_t iscsi_get_intrspec(dev_info_t *dip, dev_info_t *rdip,
    uint_t inumber);
/* LINTED E_STATIC_UNUSED */
static int iscsi_add_intrspec(dev_info_t *dip, dev_info_t *rdip,
    ddi_intrspec_t intrspec, ddi_iblock_cookie_t *iblock_cookiep,
    ddi_idevice_cookie_t *idevice_cookiep, uint_t (*int_handler)(caddr_t
    int_handler_arg), caddr_t int_handler_arg, int kind);
/* LINTED E_STATIC_UNUSED */
static void iscsi_remove_intrspec(dev_info_t *dip, dev_info_t *rdip,
    ddi_intrspec_t intrspec, ddi_iblock_cookie_t iblock_cookie);
/* LINTED E_STATIC_UNUSED */
static int iscsi_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
    void *arg, void *result);

/* cb_ops prototypes */
static int iscsi_open(dev_t *devp, int flags, int otyp, cred_t *credp);
static int iscsi_close(dev_t dev, int flag, int otyp, cred_t *credp);
static int iscsi_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *credp, int *rvalp);

int iscsi_get_persisted_param(uchar_t *name,
    iscsi_param_get_t *ipgp,
    iscsi_login_params_t *params);
static void iscsi_override_target_default(iscsi_hba_t *ihp,
    iscsi_param_get_t *ipg);

/* scsi_tran helpers */
static int iscsi_virt_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
static int iscsi_phys_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
static int iscsi_i_commoncap(struct scsi_address *ap, char *cap,
    int val, int lunonly, int doset);
static void iscsi_get_name_to_iqn(char *name, int name_max_len);
static void iscsi_get_name_from_iqn(char *name, int name_max_len);
static boolean_t iscsi_cmp_boot_sess_oid(iscsi_hba_t *ihp, uint32_t oid);

/* iscsi initiator service helpers */
static boolean_t iscsi_enter_service_zone(iscsi_hba_t *ihp, uint32_t status);
static void iscsi_exit_service_zone(iscsi_hba_t *ihp, uint32_t status);
static void iscsi_check_miniroot(iscsi_hba_t *ihp);
static void iscsi_get_tunable_default(iscsi_tunable_object_t *param);
static int iscsi_get_persisted_tunable_param(uchar_t *name,
    iscsi_tunable_object_t *tpsg);
static void iscsi_set_default_tunable_params(iscsi_tunable_params_t *params);

/* struct helpers prototypes */

/*
 * At this point this driver doesn't need this structure because nothing
 * is done during the open, close or ioctl. Code put in place because
 * some admin related work might be done in the ioctl routine.
 */
static struct cb_ops iscsi_cb_ops = {
	iscsi_open,			/* open */
	iscsi_close,			/* close */
	nodev,				/* strategy */
	nodev,				/* print */
	nodev,				/* dump */
	nodev,				/* read */
	nodev,				/* write */
	iscsi_ioctl,			/* ioctl */
	nodev,				/* devmap */
	nodev,				/* mmap */
	nodev,				/* segmap */
	nochpoll,			/* poll */
	ddi_prop_op,			/* prop_op */
	NULL,				/* streamtab */
	D_NEW | D_MP | D_HOTPLUG,	/* flags */
	CB_REV,				/* cb_rev */
	nodev,				/* aread */
	nodev,				/* awrite */
};

static struct dev_ops iscsi_dev_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* refcnt */
	iscsi_getinfo,		/* getinfo */
	nulldev,		/* identify */
	nulldev,		/* probe */
	iscsi_attach,		/* attach */
	iscsi_detach,		/* detach */
	nodev,			/* reset */
	&iscsi_cb_ops,		/* driver operations */
	NULL,			/* bus ops */
	NULL,			/* power management */
	ddi_quiesce_not_needed,	/* quiesce */
};

static struct modldrv modldrv = {
	&mod_driverops,		/* drv_modops */
	ISCSI_NAME_VERSION,	/* drv_linkinfo */
	&iscsi_dev_ops		/* drv_dev_ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,		/* ml_rev */
	&modldrv,		/* ml_linkage[] */
	NULL			/* NULL termination */
};

/*
 * This structure is bogus. scsi_hba_attach_setup() requires, as in the kernel
 * will panic if you don't pass this in to the routine, this information.
 * Need to determine what the actual impact to the system is by providing
 * this information if any. Since dma allocation is done in pkt_init it may
 * not have any impact. These values are straight from the Writing Device
 * Driver manual.
 */
static ddi_dma_attr_t iscsi_dma_attr = {
	DMA_ATTR_V0,	/* ddi_dma_attr version */
	0,		/* low address */
	0xffffffff,	/* high address */
	0x00ffffff,	/* counter upper bound */
	1,		/* alignment requirements */
	0x3f,		/* burst sizes */
	1,		/* minimum DMA access */
	0xffffffff,	/* maximum DMA access */
	(1 << 24) - 1,	/* segment boundary restrictions */
	1,		/* scater/gather list length */
	512,		/* device granularity */
	0		/* DMA flags */
};

/*
 * _init - General driver init entry
 */
int
_init(void)
{
	int rval = 0;

	iscsi_net_init();

	mutex_init(&iscsi_oid_mutex, NULL, MUTEX_DRIVER, NULL);
	iscsi_oid = ISCSI_INITIATOR_OID;

	/*
	 * Set up the soft state structures. If this driver is actually
	 * being attached to the system then we'll have at least one
	 * HBA/NIC used.
	 */
	rval = ddi_soft_state_init(&iscsi_state,
	    sizeof (iscsi_hba_t), 1);
	if (rval != 0) {
		iscsi_net_fini();
		goto init_done;
	}

	rval = scsi_hba_init(&modlinkage);
	if (rval != 0) {
		ddi_soft_state_fini(&iscsi_state);
		iscsi_net_fini();
		goto init_done;
	}

	rval = mod_install(&modlinkage);
	if (rval != 0) {
		ddi_soft_state_fini(&iscsi_state);
		scsi_hba_fini(&modlinkage);
		iscsi_net_fini();
		goto init_done;
	}
	(void) iscsi_door_ini();

init_done:
	return (rval);
}

/*
 * _fini - General driver destructor entry
 */
int
_fini(void)
{
	int rval = 0;

	rval = mod_remove(&modlinkage);
	if (rval == 0) {
		scsi_hba_fini(&modlinkage);
		ddi_soft_state_fini(&iscsi_state);
		mutex_destroy(&iscsi_oid_mutex);
		(void) iscsi_door_term();
		iscsi_net_fini();
	}
	return (rval);
}

/*
 * _info - General driver info entry
 */
int
_info(struct modinfo *mp)
{
	int rval = 0;

	rval = mod_info(&modlinkage, mp);

	return (rval);
}


/*
 * +--------------------------------------------------------------------+
 * | Start of dev_ops routines					  |
 * +--------------------------------------------------------------------+
 */

/*
 * iscsi_getinfo - returns general driver information
 */
/* ARGSUSED */
static int
iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
    void *arg, void **result)
{
	int		rval		= DDI_SUCCESS;
	int		instance	= getminor((dev_t)arg);
	iscsi_hba_t	*ip;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if ((ip = ddi_get_soft_state(iscsi_state, instance)) == NULL) {
			return (DDI_FAILURE);
		}
		*result = ip->hba_dip;
		if (ip->hba_dip == NULL)
			rval = DDI_FAILURE;
		else
			rval = DDI_SUCCESS;
		break;

	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)(uintptr_t)instance;
		rval = DDI_SUCCESS;
		break;

	default:
		rval = DDI_FAILURE;
		break;
	}
	return (rval);
}


/*
 * iscsi_attach -- Attach instance of an iSCSI HBA.  We
 * will attempt to create our HBA and register it with
 * scsi_vhci.  If it's not possible to create the HBA
 * or register with vhci we will fail the attach.
 */
static int
iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int			instance	= ddi_get_instance(dip);
	iscsi_hba_t		*ihp		= NULL;
	scsi_hba_tran_t		*tran		= NULL;
	char			init_port_name[MAX_NAME_PROP_SIZE];

	if (cmd == DDI_RESUME) {
		return (DDI_SUCCESS);
	} else if (cmd != DDI_ATTACH) {
		return (DDI_FAILURE);
	}

	if (!modrootloaded && iscsiboot_prop == NULL) {
		/*
		 * The root file system has not yet been mounted, and we're not
		 * trying to boot from an iSCSI device.  Fail to attach now so
		 * that we can retry after root has been mounted.
		 */
		return (DDI_FAILURE);
	}

	/* create iSCSI HBA devctl device node */
	if (ddi_create_minor_node(dip, ISCSI_DEVCTL, S_IFCHR, 0,
	    DDI_PSEUDO, 0) != DDI_SUCCESS) {
		goto iscsi_attach_failed3;
	}

	/* allocate HBA soft state */
	if (ddi_soft_state_zalloc(iscsi_state, instance) !=
	    DDI_SUCCESS) {
		ddi_remove_minor_node(dip, NULL);
		goto iscsi_attach_failed3;
	}

	/* get reference to soft state */
	if ((ihp = (iscsi_hba_t *)ddi_get_soft_state(
	    iscsi_state, instance)) == NULL) {
		ddi_remove_minor_node(dip, NULL);
		ddi_soft_state_free(iscsi_state, instance);
		goto iscsi_attach_failed3;
	}

	/* init HBA mutex used to protect discovery events */
	mutex_init(&ihp->hba_discovery_events_mutex, NULL,
	    MUTEX_DRIVER, NULL);

	VERIFY0(ldi_ident_from_dip(dip, &ihp->hba_li));

	/* init HBA mutex used to protect service status */
	mutex_init(&ihp->hba_service_lock, NULL,
	    MUTEX_DRIVER, NULL);
	cv_init(&ihp->hba_service_cv, NULL, CV_DRIVER, NULL);

	/*
	 * init SendTargets semaphore that is used to allow
	 * only one operation at a time
	 */
	sema_init(&ihp->hba_sendtgts_semaphore, 1, NULL,
	    SEMA_DRIVER, NULL);

	ihp->hba_sess_list = NULL;
	rw_init(&ihp->hba_sess_list_rwlock, NULL,
	    RW_DRIVER, NULL);

	/* allocate scsi_hba_tran */
	if ((tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP))
	    == NULL) {
		ddi_remove_minor_node(dip, NULL);
		goto iscsi_attach_failed2;
	}

	/* soft state setup */
	ihp->hba_sig	= ISCSI_SIG_HBA;
	ihp->hba_tran	= tran;
	ihp->hba_dip	= dip;
	if (iscsiboot_prop == NULL) {
		ihp->hba_service_status =
		    ISCSI_SERVICE_DISABLED;
		ihp->hba_service_status_overwrite = B_FALSE;
	} else {
		ihp->hba_service_status =
		    ISCSI_SERVICE_ENABLED;
		ihp->hba_service_status_overwrite = B_TRUE;
	}
	ihp->hba_service_client_count = 0;

	mutex_enter(&iscsi_oid_mutex);
	ihp->hba_oid		  = iscsi_oid++;
	mutex_exit(&iscsi_oid_mutex);

	ihp->hba_name[0]	  = '\0';
	ihp->hba_name_length	  = 0;
	ihp->hba_alias_length	  = 0;
	ihp->hba_alias[0]	  = '\0';

	iscsi_net->tweaks.rcvbuf = ddi_prop_get_int(
	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-rcvbuf",
	    ISCSI_SOCKET_RCVBUF_SIZE);

	iscsi_net->tweaks.sndbuf = ddi_prop_get_int(
	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-sndbuf",
	    ISCSI_SOCKET_SNDBUF_SIZE);

	iscsi_net->tweaks.nodelay = ddi_prop_get_int(
	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "tcp-nodelay",
	    ISCSI_TCP_NODELAY_DEFAULT);

	iscsi_net->tweaks.conn_notify_threshold =
	    ddi_prop_get_int(DDI_DEV_T_ANY,
	    ihp->hba_dip, 0, "tcp-conn-notify-threshold",
	    ISCSI_TCP_CNOTIFY_THRESHOLD_DEFAULT);

	iscsi_net->tweaks.conn_abort_threshold =
	    ddi_prop_get_int(DDI_DEV_T_ANY, ihp->hba_dip,
	    0, "tcp-conn-abort-threshold",
	    ISCSI_TCP_CABORT_THRESHOLD_DEFAULT);

	iscsi_net->tweaks.abort_threshold = ddi_prop_get_int(
	    DDI_DEV_T_ANY, ihp->hba_dip, 0,
	    "tcp-abort-threshold",
	    ISCSI_TCP_ABORT_THRESHOLD_DEFAULT);

	ihp->hba_config_storm_delay = ddi_prop_get_int(
	    DDI_DEV_T_ANY, ihp->hba_dip, 0,
	    "config-storm-delay",
	    ISCSI_CONFIG_STORM_DELAY_DEFAULT);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "so-rcvbuf", iscsi_net->tweaks.rcvbuf);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "so-sndbuf", iscsi_net->tweaks.sndbuf);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "tcp-nodelay", iscsi_net->tweaks.nodelay);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "tcp-conn-notify-threshold",
	    iscsi_net->tweaks.conn_notify_threshold);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "tcp-conn-abort-threshold",
	    iscsi_net->tweaks.conn_abort_threshold);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "tcp-abort-threshold",
	    iscsi_net->tweaks.abort_threshold);

	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
	    "config-storm-delay",
	    ihp->hba_config_storm_delay);

	/* setup hba defaults */
	iscsi_set_default_login_params(&ihp->hba_params);
	iscsi_set_default_tunable_params(
	    &ihp->hba_tunable_params);

	/* setup minimal initiator params */
	iscsid_set_default_initiator_node_settings(ihp, B_TRUE);

	/* hba set up */
	tran->tran_hba_private  = ihp;
	tran->tran_tgt_private  = NULL;
	tran->tran_tgt_init	= iscsi_tran_lun_init;
	tran->tran_tgt_probe	= iscsi_tran_lun_probe;
	tran->tran_tgt_free	= iscsi_tran_lun_free;
	tran->tran_start	= iscsi_tran_start;
	tran->tran_abort	= iscsi_tran_abort;
	tran->tran_reset	= iscsi_tran_reset;
	tran->tran_getcap	= iscsi_tran_getcap;
	tran->tran_setcap	= iscsi_tran_setcap;
	tran->tran_init_pkt	= iscsi_tran_init_pkt;
	tran->tran_destroy_pkt	= iscsi_tran_destroy_pkt;
	tran->tran_dmafree	= iscsi_tran_dmafree;
	tran->tran_sync_pkt	= iscsi_tran_sync_pkt;
	tran->tran_reset_notify	= iscsi_tran_reset_notify;
	tran->tran_bus_config	= iscsi_tran_bus_config;
	tran->tran_bus_unconfig	= iscsi_tran_bus_unconfig;

	tran->tran_get_name	= iscsi_tran_get_name;
	tran->tran_get_bus_addr	= iscsi_tran_get_bus_addr;
	tran->tran_interconnect_type = INTERCONNECT_ISCSI;

	/* register scsi hba with scsa */
	if (scsi_hba_attach_setup(dip, &iscsi_dma_attr,
	    tran, SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) {
		goto iscsi_attach_failed1;
	}

	/* register scsi hba with mdi (MPxIO/vhci) */
	if (mdi_phci_register(MDI_HCI_CLASS_SCSI, dip, 0) !=
	    MDI_SUCCESS) {
		ihp->hba_mpxio_enabled = B_FALSE;
	} else {
		ihp->hba_mpxio_enabled = B_TRUE;
	}

	(void) iscsi_hba_kstat_init(ihp);

	/* Initialize targetparam list */
	iscsi_targetparam_init();

	/* Initialize ISID */
	ihp->hba_isid[0] = ISCSI_SUN_ISID_0;
	ihp->hba_isid[1] = ISCSI_SUN_ISID_1;
	ihp->hba_isid[2] = ISCSI_SUN_ISID_2;
	ihp->hba_isid[3] = ISCSI_SUN_ISID_3;
	ihp->hba_isid[4] = ISCSI_SUN_ISID_4;
	ihp->hba_isid[5] = ISCSI_SUN_ISID_5;

	/* Setup iSNS transport services and client */
	isns_client_init();

	/*
	 * initialize persistent store,
	 * or boot target info in case of iscsi boot
	 */
	ihp->hba_persistent_loaded = B_FALSE;
	if (iscsid_init(ihp) == B_FALSE) {
		goto iscsi_attach_failed0;
	}

	/* Setup init_port_name for MPAPI */
	(void) snprintf(init_port_name, MAX_NAME_PROP_SIZE,
	    "%s,%02x%02x%02x%02x%02x%02x",
	    (char *)ihp->hba_name, ihp->hba_isid[0],
	    ihp->hba_isid[1], ihp->hba_isid[2],
	    ihp->hba_isid[3], ihp->hba_isid[4],
	    ihp->hba_isid[5]);

	if (ddi_prop_update_string(DDI_DEV_T_NONE, dip,
	    SCSI_ADDR_PROP_INITIATOR_PORT, init_port_name) !=
	    DDI_PROP_SUCCESS) {
		cmn_err(CE_WARN, "iscsi_attach: Creating "
		    SCSI_ADDR_PROP_INITIATOR_PORT
		    " property on iSCSI "
		    "HBA(%s) with dip(%d) Failed",
		    (char *)ihp->hba_name,
		    ddi_get_instance(dip));
	}

	ddi_report_dev(dip);
	return (DDI_SUCCESS);

iscsi_attach_failed0:
	isns_client_cleanup();
	if (ihp->stats.ks) {
		(void) iscsi_hba_kstat_term(ihp);
	}
	if (ihp->hba_mpxio_enabled == B_TRUE) {
		(void) mdi_phci_unregister(dip, 0);
	}
	(void) scsi_hba_detach(ihp->hba_dip);
iscsi_attach_failed1:
	ddi_remove_minor_node(dip, NULL);
	ddi_prop_remove_all(ihp->hba_dip);
	scsi_hba_tran_free(tran);
iscsi_attach_failed2:
	cv_destroy(&ihp->hba_service_cv);
	mutex_destroy(&ihp->hba_service_lock);
	mutex_destroy(&ihp->hba_discovery_events_mutex);
	sema_destroy(&ihp->hba_sendtgts_semaphore);
	rw_destroy(&ihp->hba_sess_list_rwlock);
	ddi_soft_state_free(iscsi_state, instance);
iscsi_attach_failed3:
	cmn_err(CE_WARN, "iscsi driver unable to attach "
	    "hba instance %d", instance);
	return (DDI_FAILURE);
}

/*
 * iscsi_detach - called on unload of hba instance
 */
static int
iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int			rval		= DDI_SUCCESS;
	scsi_hba_tran_t		*tran		= NULL;
	iscsi_hba_t		*ihp		= NULL;
	iscsi_hba_t		*ihp_check	= NULL;
	int			instance;
	char			*init_node_name;

	instance = ddi_get_instance(dip);

	switch (cmd) {
	case DDI_DETACH:
		if (!(tran = (scsi_hba_tran_t *)ddi_get_driver_private(dip))) {
			rval = DDI_SUCCESS;
			break;
		}

		if ((ihp = (iscsi_hba_t *)tran->tran_hba_private) == NULL) {
			rval =  DDI_FAILURE;
			break;
		}

		/*
		 * Validate that what is stored by the DDI framework is still
		 * the same state structure referenced by the SCSI framework
		 */
		ihp_check = ddi_get_soft_state(iscsi_state, instance);
		if (ihp_check != ihp) {
			rval = DDI_FAILURE;
			break;
		}

		/* If a session exists we can't safely detach */
		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
		if (ihp->hba_sess_list != NULL) {
			rw_exit(&ihp->hba_sess_list_rwlock);
			rval = DDI_FAILURE;
			break;
		}
		rw_exit(&ihp->hba_sess_list_rwlock);

		/* Disable all discovery services */
		if (iscsid_disable_discovery(ihp,
		    ISCSI_ALL_DISCOVERY_METHODS) == B_FALSE) {
			/* Disable failed.  Fail detach */
			rval = DDI_FAILURE;
			break;
		}

		/* Deregister from iSNS server(s). */
		init_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
		if (persistent_initiator_name_get(init_node_name,
		    ISCSI_MAX_NAME_LEN) == B_TRUE) {
			if (strlen(init_node_name) > 0) {
				(void) isns_dereg(ihp->hba_isid,
				    (uint8_t *)init_node_name);
			}
		}
		kmem_free(init_node_name, ISCSI_MAX_NAME_LEN);
		init_node_name = NULL;

		/* Cleanup iSNS Client */
		isns_client_cleanup();

		iscsi_targetparam_cleanup();

		/* Cleanup iscsid resources */
		iscsid_fini();

		if (rval != DDI_SUCCESS) {
			break;
		}
		/* kstat hba. destroy */
		KSTAT_DEC_HBA_CNTR_SESS(ihp);

		if (ihp->hba_mpxio_enabled == B_TRUE) {
			(void) mdi_phci_unregister(dip, 0);
		}
		ddi_remove_minor_node(dip, NULL);

		ddi_prop_remove_all(ihp->hba_dip);

		ldi_ident_release(ihp->hba_li);

		cv_destroy(&ihp->hba_service_cv);
		mutex_destroy(&ihp->hba_service_lock);
		mutex_destroy(&ihp->hba_discovery_events_mutex);
		rw_destroy(&ihp->hba_sess_list_rwlock);
		(void) iscsi_hba_kstat_term(ihp);

		(void) scsi_hba_detach(dip);
		if (tran != NULL) {
			scsi_hba_tran_free(tran);
		}
		ddi_soft_state_free(iscsi_state, instance);
		break;
	default:
		break;
	}

	if (rval != DDI_SUCCESS) {
		cmn_err(CE_WARN, "iscsi driver unable to "
		    "detach hba instance %d", instance);
	}

	return (rval);
}

/*
 * +--------------------------------------------------------------------+
 * | End of dev_ops routines						|
 * +--------------------------------------------------------------------+
 */

/*
 * +--------------------------------------------------------------------+
 * | scsi_tran(9E) routines						|
 * +--------------------------------------------------------------------+
 */

/*
 * iscsi_tran_lun_init - Find target device based on SCSI device
 * Based on the information given (SCSI device, target dev_info) find
 * the target iSCSI device and put a pointer to that information in
 * the scsi_hba_tran_t structure.
 */
static int
iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
{
	int		rval	= 0;
	int		type	= 0;

	ASSERT(hba_tran->tran_hba_private != NULL);

	/*
	 * Child node is getting initialized.  Look at the mpxio component
	 * type on the child device to see if this device is mpxio managed
	 * or not.
	 */
	type = mdi_get_component_type(lun_dip);
	if (type != MDI_COMPONENT_CLIENT) {
		rval = iscsi_phys_lun_init(hba_dip, lun_dip, hba_tran, sd);
	} else {
		rval = iscsi_virt_lun_init(hba_dip, lun_dip, hba_tran, sd);
	}

	return (rval);
}

/*
 * iscsi_tran_lun_probe - This function didn't need to be implemented.
 * We could have left NULL in the tran table.  Since this isn't a
 * performance path this seems safe.  We are just wrappering the
 * function so we can see the call go through if we have debugging
 * enabled.
 */
static int
iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ())
{
	int rval = 0;

	rval = scsi_hba_probe(sd, callback);

	return (rval);
}

/*
 * iscsi_init_pkt - Allocate SCSI packet and fill in required info.
 */
/* ARGSUSED */
static struct scsi_pkt *
iscsi_tran_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
    struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
    int (*callback) (), caddr_t arg)
{
	iscsi_lun_t *ilp;
	iscsi_cmd_t *icmdp;

	ASSERT(ap != NULL);
	ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);

	/*
	 * The software stack doesn't have DMA which means the iSCSI
	 * protocol layer will be doing a bcopy from bp to outgoing
	 * streams buffers. Make sure that the buffer is mapped in
	 * so that the copy won't panic the system.
	 */
	if (bp && (bp->b_bcount != 0) &&
	    bp_mapin_common(bp, (callback == NULL_FUNC) ?
	    VM_NOSLEEP : VM_SLEEP) == NULL) {
		return (NULL);
	}

	ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private;
	ASSERT(ilp != NULL);

	if (pkt == NULL) {
		pkt = scsi_hba_pkt_alloc(ilp->lun_sess->sess_hba->hba_dip,
		    ap, cmdlen, statuslen, tgtlen, sizeof (iscsi_cmd_t),
		    callback, arg);
		if (pkt == NULL) {
			return (NULL);
		}
		icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private;
		icmdp->cmd_sig			= ISCSI_SIG_CMD;
		icmdp->cmd_state		= ISCSI_CMD_STATE_FREE;
		icmdp->cmd_lun			= ilp;
		iscsi_lun_hold(ilp);
		icmdp->cmd_type			= ISCSI_CMD_TYPE_SCSI;
		/* add the report lun addressing type on to the lun */
		icmdp->cmd_un.scsi.lun		= ilp->lun_addr_type << 14;
		icmdp->cmd_un.scsi.lun		= icmdp->cmd_un.scsi.lun |
		    ilp->lun_num;
		icmdp->cmd_un.scsi.pkt		= pkt;
		icmdp->cmd_un.scsi.bp		= bp;
		icmdp->cmd_un.scsi.cmdlen	= cmdlen;
		icmdp->cmd_un.scsi.statuslen	= statuslen;
		icmdp->cmd_crc_error_seen	= B_FALSE;
		icmdp->cmd_misc_flags		= 0;
		if (flags & PKT_XARQ) {
			icmdp->cmd_misc_flags |= ISCSI_CMD_MISCFLAG_XARQ;
		}


		idm_sm_audit_init(&icmdp->cmd_state_audit);

		mutex_init(&icmdp->cmd_mutex, NULL, MUTEX_DRIVER, NULL);
		cv_init(&icmdp->cmd_completion, NULL, CV_DRIVER, NULL);

		pkt->pkt_address		= *ap;
		pkt->pkt_comp			= (void (*)())NULL;
		pkt->pkt_flags			= 0;
		pkt->pkt_time			= 0;
		pkt->pkt_resid			= 0;
		pkt->pkt_statistics		= 0;
		pkt->pkt_reason			= 0;
	}
	return (pkt);
}

/*
 * iscsi_tran_lun_free - Free a SCSI LUN
 */
static void
iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
{
	iscsi_lun_t *ilp = NULL;

	ASSERT(hba_dip != NULL);
	ASSERT(lun_dip != NULL);
	ASSERT(hba_tran != NULL);
	ASSERT(sd != NULL);
	ilp = (iscsi_lun_t *)hba_tran->tran_tgt_private;
	ASSERT(ilp != NULL);

	(void) mdi_prop_remove(ilp->lun_pip, NULL);
}

/*
 * iscsi_start -- Start a SCSI transaction based on the packet
 * This will attempt to add the icmdp to the pending queue
 * for the connection and kick the queue.  If the enqueue
 * fails that means the queue is full.
 */
static int
iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt)
{
	iscsi_lun_t	*ilp		= NULL;
	iscsi_sess_t	*isp		= NULL;
	iscsi_cmd_t	*icmdp		= NULL;
	uint_t		flags;

	ASSERT(ap != NULL);
	ASSERT(pkt != NULL);
	ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private;
	isp = (iscsi_sess_t *)ilp->lun_sess;
	icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private;