xref: /illumos-gate/usr/src/uts/common/io/fcoe/fcoe.c (revision 1a5e258f)

/*
 * 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.
 */
/*
 * Copyright 2012 Garrett D'Amore <garrett@damore.org>.  All rights reserved.
 */

/*
 * The following notice accompanied the original version of this file:
 *
 * BSD LICENSE
 *
 * Copyright(c) 2007 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Common FCoE interface interacts with MAC and FCoE clients, managing
 * FCoE ports, doing MAC address discovery/managment, and FC frame
 * encapsulation/decapsulation
 */

#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/cred.h>

#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/byteorder.h>
#include <sys/atomic.h>
#include <sys/sysmacros.h>
#include <sys/cmn_err.h>
#include <sys/crc32.h>
#include <sys/strsubr.h>

#include <sys/mac_client.h>

/*
 * FCoE header files
 */
#include <sys/fcoe/fcoeio.h>
#include <sys/fcoe/fcoe_common.h>

/*
 * Driver's own header files
 */
#include <fcoe.h>
#include <fcoe_fc.h>
#include <fcoe_eth.h>

/*
 * Function forward declaration
 */
static int fcoe_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int fcoe_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int fcoe_bus_ctl(dev_info_t *fca_dip, dev_info_t *rip,
    ddi_ctl_enum_t op, void *arg, void *result);
static int fcoe_open(dev_t *devp, int flag, int otype, cred_t *credp);
static int fcoe_close(dev_t dev, int flag, int otype, cred_t *credp);
static int fcoe_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
    cred_t *credp, int *rval);
static int fcoe_copyin_iocdata(intptr_t data, int mode, fcoeio_t **fcoeio,
    void **ibuf, void **abuf, void **obuf);
static int fcoe_copyout_iocdata(intptr_t data, int mode, fcoeio_t *fcoeio,
    void *obuf);
static int fcoe_iocmd(fcoe_soft_state_t *ss, intptr_t data, int mode);
static int fcoe_attach_init(fcoe_soft_state_t *this_ss);
static int fcoe_detach_uninit(fcoe_soft_state_t *this_ss);
static int fcoe_initchild(dev_info_t *fcoe_dip, dev_info_t *client_dip);
static int fcoe_uninitchild(dev_info_t *fcoe_dip, dev_info_t *client_dip);
static void fcoe_init_wwn_from_mac(uint8_t *wwn, uint8_t *mac,
    int is_pwwn, uint8_t idx);
static fcoe_mac_t *fcoe_create_mac_by_id(datalink_id_t linkid);
static int fcoe_cmp_wwn(fcoe_mac_t *checkedmac);
static void fcoe_watchdog(void *arg);
static void fcoe_worker_init();
static int fcoe_worker_fini();
static void fcoe_worker_frame();
static int fcoe_get_port_list(fcoe_port_instance_t *ports, int count);
static boolean_t fcoe_mac_existed(fcoe_mac_t *pmac);

/*
 * Driver identificaton stuff
 */
static struct cb_ops fcoe_cb_ops = {
	fcoe_open,
	fcoe_close,
	nodev,
	nodev,
	nodev,
	nodev,
	nodev,
	fcoe_ioctl,
	nodev,
	nodev,
	nodev,
	nochpoll,
	ddi_prop_op,
	0,
	D_MP | D_NEW | D_HOTPLUG,
	CB_REV,
	nodev,
	nodev
};

static struct bus_ops fcoe_busops = {
	BUSO_REV,
	nullbusmap,			/* bus_map */
	NULL,				/* bus_get_intrspec */
	NULL,				/* bus_add_intrspec */
	NULL,				/* bus_remove_intrspec */
	i_ddi_map_fault,		/* bus_map_fault */
	NULL,				/* bus_dma_map */
	ddi_dma_allochdl,		/* bus_dma_allochdl */
	ddi_dma_freehdl,		/* bus_dma_freehdl */
	ddi_dma_bindhdl,		/* bus_dma_bindhdl */
	ddi_dma_unbindhdl,		/* bus_unbindhdl */
	ddi_dma_flush,			/* bus_dma_flush */
	ddi_dma_win,			/* bus_dma_win */
	ddi_dma_mctl,			/* bus_dma_ctl */
	fcoe_bus_ctl,			/* bus_ctl */
	ddi_bus_prop_op,		/* bus_prop_op */
	NULL,				/* bus_get_eventcookie */
	NULL,				/* bus_add_eventcall */
	NULL,				/* bus_remove_event */
	NULL,				/* bus_post_event */
	NULL,				/* bus_intr_ctl */
	NULL,				/* bus_config */
	NULL,				/* bus_unconfig */
	NULL,				/* bus_fm_init */
	NULL,				/* bus_fm_fini */
	NULL,				/* bus_fm_access_enter */
	NULL,				/* bus_fm_access_exit */
	NULL,				/* bus_power */
	NULL
};

static struct dev_ops fcoe_ops = {
	DEVO_REV,
	0,
	nodev,
	nulldev,
	nulldev,
	fcoe_attach,
	fcoe_detach,
	nodev,
	&fcoe_cb_ops,
	&fcoe_busops,
	ddi_power,
	ddi_quiesce_not_needed
};

#define	FCOE_VERSION	"20091123-1.02"
#define	FCOE_NAME	"FCoE Transport v" FCOE_VERSION
#define	TASKQ_NAME_LEN	32

static struct modldrv modldrv = {
	&mod_driverops,
	FCOE_NAME,
	&fcoe_ops,
};

static struct modlinkage modlinkage = {
	MODREV_1, &modldrv, NULL
};

/*
 * TRACE for all FCoE related modules
 */
static kmutex_t fcoe_trace_buf_lock;
static int	fcoe_trace_buf_curndx	= 0;
static int	fcoe_trace_on		= 1;
static caddr_t	fcoe_trace_buf		= NULL;
static clock_t	fcoe_trace_start	= 0;
static caddr_t	ftb			= NULL;
static int	fcoe_trace_buf_size	= (1 * 1024 * 1024);

/*
 * Driver's global variables
 */
const fcoe_ver_e	 fcoe_ver_now	  = FCOE_VER_NOW;
static void		*fcoe_state	  = NULL;
fcoe_soft_state_t	*fcoe_global_ss	  = NULL;
int			 fcoe_use_ext_log = 1;

static ddi_taskq_t	*fcoe_worker_taskq;
static fcoe_worker_t	*fcoe_workers;
static uint32_t		fcoe_nworkers_running;

const char		*fcoe_workers_num = "workers-number";
volatile int		fcoe_nworkers;

/*
 * Common loadable module entry points _init, _fini, _info
 */

int
_init(void)
{
	int ret;

	ret = ddi_soft_state_init(&fcoe_state, sizeof (fcoe_soft_state_t), 0);
	if (ret == 0) {
		ret = mod_install(&modlinkage);
		if (ret != 0) {
			ddi_soft_state_fini(&fcoe_state);
		} else {
			fcoe_trace_start = ddi_get_lbolt();
			ftb = kmem_zalloc(fcoe_trace_buf_size,
			    KM_SLEEP);
			fcoe_trace_buf = ftb;
			mutex_init(&fcoe_trace_buf_lock, NULL, MUTEX_DRIVER, 0);
		}
	}

	FCOE_LOG("fcoe", "exit _init with %x", ret);

	return (ret);
}

int
_fini(void)
{
	int ret;

	ret = mod_remove(&modlinkage);
	if (ret == 0) {
		ddi_soft_state_fini(&fcoe_state);
	}

	FCOE_LOG("fcoe", "exit _fini with %x", ret);
	if (ret == 0) {
		kmem_free(fcoe_trace_buf, fcoe_trace_buf_size);
		mutex_destroy(&fcoe_trace_buf_lock);
	}

	return (ret);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

/*
 * Autoconfiguration entry points: attach, detach, getinfo
 */

static int
fcoe_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int			 ret = DDI_FAILURE;
	int			 fcoe_ret;
	int			 instance;
	fcoe_soft_state_t	*ss;

	instance = ddi_get_instance(dip);
	switch (cmd) {
	case DDI_ATTACH:
		ret = ddi_soft_state_zalloc(fcoe_state, instance);
		if (ret == DDI_FAILURE) {
			FCOE_LOG(0, "soft_state_zalloc-%x/%x", ret, instance);
			return (ret);
		}

		ss = ddi_get_soft_state(fcoe_state, instance);
		ss->ss_dip = dip;

		ASSERT(fcoe_global_ss == NULL);
		fcoe_global_ss = ss;
		fcoe_ret = fcoe_attach_init(ss);
		if (fcoe_ret == FCOE_SUCCESS) {
			ret = DDI_SUCCESS;
		}

		FCOE_LOG("fcoe", "fcoe_attach_init end with-%x", fcoe_ret);
		break;

	case DDI_RESUME:
		ret = DDI_SUCCESS;
		break;

	default:
		FCOE_LOG("fcoe", "unsupported attach cmd-%x", cmd);
		break;
	}

	return (ret);
}

static int
fcoe_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int			 ret = DDI_FAILURE;
	int			 fcoe_ret;
	int			 instance;
	fcoe_soft_state_t	*ss;

	instance = ddi_get_instance(dip);
	ss = ddi_get_soft_state(fcoe_state, instance);
	if (ss == NULL) {
		return (ret);
	}

	ASSERT(fcoe_global_ss != NULL);
	ASSERT(dip == fcoe_global_ss->ss_dip);
	switch (cmd) {
	case DDI_DETACH:
		fcoe_ret = fcoe_detach_uninit(ss);
		if (fcoe_ret == FCOE_SUCCESS) {
			ret = DDI_SUCCESS;
			fcoe_global_ss = NULL;
		}

		break;

	case DDI_SUSPEND:
		ret = DDI_SUCCESS;
		break;

	default:
		FCOE_LOG(0, "unsupported detach cmd-%x", cmd);
		break;
	}

	return (ret);
}

/*
 * FCA driver's intercepted bus control operations.
 */
static int
fcoe_bus_ctl(dev_info_t *fcoe_dip, dev_info_t *rip,
    ddi_ctl_enum_t op, void *clientarg, void *result)
{
	int ret;
	switch (op) {
	case DDI_CTLOPS_REPORTDEV:
	case DDI_CTLOPS_IOMIN:
		ret = DDI_SUCCESS;
		break;

	case DDI_CTLOPS_INITCHILD:
		ret = fcoe_initchild(fcoe_dip, (dev_info_t *)clientarg);
		break;

	case DDI_CTLOPS_UNINITCHILD:
		ret = fcoe_uninitchild(fcoe_dip, (dev_info_t *)clientarg);
		break;

	default:
		ret = ddi_ctlops(fcoe_dip, rip, op, clientarg, result);
		break;
	}

	return (ret);
}

/*
 * We need specify the dev address for client driver's instance, or we
 * can't online client driver's instance.
 */
/* ARGSUSED */
static int
fcoe_initchild(dev_info_t *fcoe_dip, dev_info_t *client_dip)
{
	char	client_addr[FCOE_STR_LEN];
	int	rval;

	rval = ddi_prop_get_int(DDI_DEV_T_ANY, client_dip,
	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "mac_id", -1);
	if (rval == -1) {
		FCOE_LOG(__FUNCTION__, "no mac_id property: %p", client_dip);
		return (DDI_FAILURE);
	}

	bzero(client_addr, FCOE_STR_LEN);
	(void) sprintf((char *)client_addr, "%x,0", rval);
	ddi_set_name_addr(client_dip, client_addr);
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
fcoe_uninitchild(dev_info_t *fcoe_dip, dev_info_t *client_dip)
{
	ddi_set_name_addr(client_dip, NULL);
	return (DDI_SUCCESS);
}

/*
 * Device access entry points
 */
static int
fcoe_open(dev_t *devp, int flag, int otype, cred_t *credp)
{
	int			 instance;
	fcoe_soft_state_t	*ss;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	/*
	 * Since this is for debugging only, only allow root to issue ioctl now
	 */
	if (drv_priv(credp) != 0) {
		return (EPERM);
	}

	instance = (int)getminor(*devp);
	ss = ddi_get_soft_state(fcoe_state, instance);
	if (ss == NULL) {
		return (ENXIO);
	}

	mutex_enter(&ss->ss_ioctl_mutex);
	if (ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_EXCL) {
		/*
		 * It is already open for exclusive access.
		 * So shut the door on this caller.
		 */
		mutex_exit(&ss->ss_ioctl_mutex);
		return (EBUSY);
	}

	if (flag & FEXCL) {
		if (ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_OPEN) {
			/*
			 * Exclusive operation not possible
			 * as it is already opened
			 */
			mutex_exit(&ss->ss_ioctl_mutex);
			return (EBUSY);
		}
		ss->ss_ioctl_flags |= FCOE_IOCTL_FLAG_EXCL;
	}

	ss->ss_ioctl_flags |= FCOE_IOCTL_FLAG_OPEN;
	mutex_exit(&ss->ss_ioctl_mutex);

	return (0);
}

/* ARGSUSED */
static int
fcoe_close(dev_t dev, int flag, int otype, cred_t *credp)
{
	int			 instance;
	fcoe_soft_state_t	*ss;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	instance = (int)getminor(dev);
	ss = ddi_get_soft_state(fcoe_state, instance);
	if (ss == NULL) {
		return (ENXIO);
	}

	mutex_enter(&ss->ss_ioctl_mutex);
	if ((ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_OPEN) == 0) {
		mutex_exit(&ss->ss_ioctl_mutex);
		return (ENODEV);
	}

	ss->ss_ioctl_flags &= ~FCOE_IOCTL_FLAG_MASK;
	mutex_exit(&ss->ss_ioctl_mutex);

	return (0);
}

/* ARGSUSED */
static int
fcoe_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
    cred_t *credp, int *rval)
{
	fcoe_soft_state_t	*ss;
	int			 ret = 0;

	if (drv_priv(credp) != 0) {
		return (EPERM);
	}

	ss = ddi_get_soft_state(fcoe_state, (int32_t)getminor(dev));
	if (ss == NULL) {
		return (ENXIO);
	}

	mutex_enter(&ss->ss_ioctl_mutex);
	if ((ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_OPEN) == 0) {
		mutex_exit(&ss->ss_ioctl_mutex);
		return (ENXIO);
	}
	mutex_exit(&ss->ss_ioctl_mutex);

	switch (cmd) {
	case FCOEIO_CMD:
		ret = fcoe_iocmd(ss, data, mode);
		break;
	default:
		FCOE_LOG(0, "fcoe_ioctl: ioctl-0x%02X", cmd);
		ret = ENOTTY;
		break;
	}

	return (ret);
}

static int
fcoe_copyin_iocdata(intptr_t data, int mode, fcoeio_t **fcoeio,
    void **ibuf, void **abuf, void **obuf)
{
	int ret = 0;

	*ibuf = NULL;
	*abuf = NULL;
	*obuf = NULL;
	*fcoeio = kmem_zalloc(sizeof (fcoeio_t), KM_SLEEP);
	if (ddi_copyin((void *)data, *fcoeio, sizeof (fcoeio_t), mode) != 0) {
		ret = EFAULT;
		goto copyin_iocdata_fail;
	}

	if ((*fcoeio)->fcoeio_ilen > FCOEIO_MAX_BUF_LEN ||
	    (*fcoeio)->fcoeio_alen > FCOEIO_MAX_BUF_LEN ||
	    (*fcoeio)->fcoeio_olen > FCOEIO_MAX_BUF_LEN) {
		ret = EFAULT;
		goto copyin_iocdata_fail;
	}

	if ((*fcoeio)->fcoeio_ilen) {
		*ibuf = kmem_zalloc((*fcoeio)->fcoeio_ilen, KM_SLEEP);
		if (ddi_copyin((void *)(unsigned long)(*fcoeio)->fcoeio_ibuf,
		    *ibuf, (*fcoeio)->fcoeio_ilen, mode) != 0) {
			ret = EFAULT;
			goto copyin_iocdata_fail;
		}
	}

	if ((*fcoeio)->fcoeio_alen) {
		*abuf = kmem_zalloc((*fcoeio)->fcoeio_alen, KM_SLEEP);
		if (ddi_copyin((void *)(unsigned long)(*fcoeio)->fcoeio_abuf,
		    *abuf, (*fcoeio)->fcoeio_alen, mode) != 0) {
			ret = EFAULT;
			goto copyin_iocdata_fail;
		}
	}

	if ((*fcoeio)->fcoeio_olen) {
		*obuf = kmem_zalloc((*fcoeio)->fcoeio_olen, KM_SLEEP);
	}
	return (ret);

copyin_iocdata_fail:
	if (*abuf) {
		kmem_free(*abuf, (*fcoeio)->fcoeio_alen);
		*abuf = NULL;
	}

	if (*ibuf) {
		kmem_free(*ibuf, (*fcoeio)->fcoeio_ilen);
		*ibuf = NULL;
	}

	kmem_free(*fcoeio, sizeof (fcoeio_t));
	return (ret);
}

static int
fcoe_copyout_iocdata(intptr_t data, int mode, fcoeio_t *fcoeio, void *obuf)
{
	if (fcoeio->fcoeio_olen) {
		if (ddi_copyout(obuf,
		    (void *)(unsigned long)fcoeio->fcoeio_obuf,
		    fcoeio->fcoeio_olen, mode) != 0) {
			return (EFAULT);
		}
	}

	if (ddi_copyout(fcoeio, (void *)data, sizeof (fcoeio_t), mode) != 0) {
		return (EFAULT);
	}
	return (0);
}

static int
fcoe_iocmd(fcoe_soft_state_t *ss, intptr_t data, int mode)
{
	int		ret;
	fcoe_mac_t	*fcoe_mac;
	void		*ibuf = NULL;
	void		*obuf = NULL;
	void		*abuf = NULL;
	fcoeio_t	*fcoeio;

	ret = fcoe_copyin_iocdata(data, mode, &fcoeio, &ibuf, &abuf, &obuf);
	if (ret != 0) {
		goto fcoeiocmd_release_buf;
	}

	/*
	 * If an exclusive open was demanded during open, ensure that
	 * only one thread can execute an ioctl at a time
	 */
	mutex_enter(&ss->ss_ioctl_mutex);
	if (ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_EXCL) {
		if (ss->ss_ioctl_flags & FCOE_IOCTL_FLAG_EXCL_BUSY) {
			mutex_exit(&ss->ss_ioctl_mutex);
			fcoeio->fcoeio_status = FCOEIOE_BUSY;
			ret = EBUSY;
			goto fcoeiocmd_release_buf;
		}
		ss->ss_ioctl_flags |= FCOE_IOCTL_FLAG_EXCL_BUSY;
	}
	mutex_exit(&ss->ss_ioctl_mutex);

	fcoeio->fcoeio_status = 0;

	switch (fcoeio->fcoeio_cmd) {
	case FCOEIO_CREATE_FCOE_PORT: {
		fcoeio_create_port_param_t	*param =
		    (fcoeio_create_port_param_t *)ibuf;
		int		cmpwwn = 0;
		fcoe_port_t	*eport;

		if (fcoeio->fcoeio_ilen !=
		    sizeof (fcoeio_create_port_param_t) ||
		    fcoeio->fcoeio_xfer != FCOEIO_XFER_WRITE) {
			fcoeio->fcoeio_status = FCOEIOE_INVAL_ARG;
			ret = EINVAL;
			break;
		}

		mutex_enter(&ss->ss_ioctl_mutex);
		fcoe_mac = fcoe_create_mac_by_id(param->fcp_mac_linkid);
		if (fcoe_mac == NULL) {
			mutex_exit(&ss->ss_ioctl_mutex);
			fcoeio->fcoeio_status = FCOEIOE_CREATE_MAC;
			ret = EIO;
			break;
		}

		if (fcoe_mac->fm_flags & FCOE_MAC_FLAG_ENABLED) {
			mutex_exit(&ss->ss_ioctl_mutex);
			fcoeio->fcoeio_status = FCOEIOE_ALREADY;
			ret = EALREADY;
			break;
		} else {
			ret = fcoe_open_mac(fcoe_mac, param->fcp_force_promisc,
			    &fcoeio->fcoeio_status);
			if (ret != 0) {
				fcoe_destroy_mac(fcoe_mac);
				mutex_exit(&ss->ss_ioctl_mutex);
				if (fcoeio->fcoeio_status == 0) {
					fcoeio->fcoeio_status =
					    FCOEIOE_OPEN_MAC;
				}
				ret = EIO;
				break;
			} else {
				fcoe_mac->fm_flags |= FCOE_MAC_FLAG_ENABLED;
			}
		}

		/*
		 * Provide PWWN and NWWN based on mac address
		 */
		eport = &fcoe_mac->fm_eport;
		if (!param->fcp_pwwn_provided) {
			fcoe_init_wwn_from_mac(eport->eport_portwwn,
			    fcoe_mac->fm_current_addr, 1, 0);
		} else {
			(void) memcpy(eport->eport_portwwn, param->fcp_pwwn, 8);
		}

		if (!param->fcp_nwwn_provided) {
			fcoe_init_wwn_from_mac(eport->eport_nodewwn,
			    fcoe_mac->fm_current_addr, 0, 0);
		} else {
			(void) memcpy(eport->eport_nodewwn, param->fcp_nwwn, 8);
		}

		cmpwwn = fcoe_cmp_wwn(fcoe_mac);

		if (cmpwwn != 0) {
			if (cmpwwn == 1) {
				fcoeio->fcoeio_status = FCOEIOE_PWWN_CONFLICTED;
			} else if (cmpwwn == -1) {
				fcoeio->fcoeio_status = FCOEIOE_NWWN_CONFLICTED;
			}
			(void) fcoe_close_mac(fcoe_mac);
			fcoe_destroy_mac(fcoe_mac);
			mutex_exit(&ss->ss_ioctl_mutex);
			ret = ENOTUNIQ;
			break;
		}

		if (ret == 0) {
			ret = fcoe_create_port(ss->ss_dip,
			    fcoe_mac,
			    (param->fcp_port_type == FCOE_CLIENT_TARGET));
			if (ret != 0) {
				if (fcoe_mac_existed(fcoe_mac) == B_TRUE) {
					(void) fcoe_close_mac(fcoe_mac);
					fcoe_destroy_mac(fcoe_mac);
				}
				fcoeio->fcoeio_status = FCOEIOE_CREATE_PORT;
				ret = EIO;
			}
		}
		mutex_exit(&ss->ss_ioctl_mutex);

		break;
	}

	case FCOEIO_DELETE_FCOE_PORT: {
		fcoeio_delete_port_param_t *del_port_param =
		    (fcoeio_delete_port_param_t *)ibuf;
		uint64_t *is_target = (uint64_t *)obuf;

		if (fcoeio->fcoeio_ilen < sizeof (fcoeio_delete_port_param_t) ||
		    fcoeio->fcoeio_olen != sizeof (uint64_t) ||
		    fcoeio->fcoeio_xfer != FCOEIO_XFER_RW) {
			fcoeio->fcoeio_status = FCOEIOE_INVAL_ARG;
			ret = EINVAL;
			break;
		}

		mutex_enter(&ss->ss_ioctl_mutex);
		ret = fcoe_delete_port(ss->ss_dip, fcoeio,
		    del_port_param->fdp_mac_linkid, is_target);
		mutex_exit(&ss->ss_ioctl_mutex);
		FCOE_LOG("fcoe", "fcoe_delete_port %x return: %d",
		    del_port_param->fdp_mac_linkid, ret);
		break;
	}

	case FCOEIO_GET_FCOE_PORT_LIST: {
		fcoe_port_list_t *list = (fcoe_port_list_t *)obuf;
		int		count;

		if (fcoeio->fcoeio_xfer != FCOEIO_XFER_READ ||
		    fcoeio->fcoeio_olen < sizeof (fcoe_port_list_t)) {
			fcoeio->fcoeio_status = FCOEIOE_INVAL_ARG;
			ret = EINVAL;
			break;
		}
		mutex_enter(&ss->ss_ioctl_mutex);

		list->numPorts = 1 + (fcoeio->fcoeio_olen -
		    sizeof (fcoe_port_list_t))/sizeof (fcoe_port_instance_t);

		count = fcoe_get_port_list(list->ports, list->numPorts);

		if (count > list->numPorts) {
			fcoeio->fcoeio_status = FCOEIOE_MORE_DATA;
			ret = ENOSPC;
		}
		list->numPorts = count;
		mutex_exit(&ss->ss_ioctl_mutex);

		break;

	}

	default:
		return (ENOTTY);
	}

	FCOE_LOG("fcoe", "fcoe_ioctl %x returned %d, fcoeio_status = %d",
	    fcoeio->fcoeio_cmd, ret, fcoeio->fcoeio_status);

fcoeiocmd_release_buf:
	if (ret == 0) {
		ret = fcoe_copyout_iocdata(data, mode, fcoeio, obuf);
	} else if (fcoeio->fcoeio_status) {
		(void) fcoe_copyout_iocdata(data, mode, fcoeio, obuf);
	}

	if (obuf != NULL) {
		kmem_free(obuf, fcoeio->fcoeio_olen);
		obuf = NULL;
	}
	if (abuf != NULL) {
		kmem_free(abuf, fcoeio->fcoeio_alen);
		abuf = NULL;
	}

	if (ibuf != NULL) {
		kmem_free(ibuf, fcoeio->fcoeio_ilen);
		ibuf = NULL;
	}
	kmem_free(fcoeio, sizeof (fcoeio_t));

	return (ret);
}

/*
 * Finish final initialization
 */
static int
fcoe_attach_init(fcoe_soft_state_t *ss)
{
	char taskq_name[TASKQ_NAME_LEN];

	if (ddi_create_minor_node(ss->ss_dip, "admin", S_IFCHR,
	    ddi_get_instance(ss->ss_dip), DDI_PSEUDO, 0) != DDI_SUCCESS) {
		FCOE_LOG("FCOE", "ddi_create_minor_node failed");
		return (FCOE_FAILURE);
	}

	/*
	 * watchdog responsible for release frame and dispatch events
	 */
	(void) snprintf(taskq_name, sizeof (taskq_name), "fcoe_mac");
	taskq_name[TASKQ_NAME_LEN - 1] = 0;
	if ((ss->ss_watchdog_taskq = ddi_taskq_create(NULL,
	    taskq_name, 2, TASKQ_DEFAULTPRI, 0)) == NULL) {
		return (FCOE_FAILURE);
	}

	ss->ss_ioctl_flags = 0;
	mutex_init(&ss->ss_ioctl_mutex, NULL, MUTEX_DRIVER, NULL);
	list_create(&ss->ss_mac_list, sizeof (fcoe_mac_t),
	    offsetof(fcoe_mac_t, fm_ss_node));
	list_create(&ss->ss_pfrm_list, sizeof (fcoe_i_frame_t),
	    offsetof(fcoe_i_frame_t, fmi_pending_node));

	mutex_init(&ss->ss_watch_mutex, 0, MUTEX_DRIVER, 0);
	cv_init(&ss->ss_watch_cv, NULL, CV_DRIVER, NULL);
	ss->ss_flags &= ~SS_FLAG_TERMINATE_WATCHDOG;
	(void) ddi_taskq_dispatch(ss->ss_watchdog_taskq,
	    fcoe_watchdog, ss, DDI_SLEEP);
	while ((ss->ss_flags & SS_FLAG_WATCHDOG_RUNNING) == 0) {
		delay(10);
	}
	fcoe_nworkers = ddi_prop_get_int(DDI_DEV_T_ANY, ss->ss_dip,
	    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, (char *)fcoe_workers_num, 4);
	if (fcoe_nworkers < 1) {
		fcoe_nworkers = 4;
	}
	fcoe_worker_init();

	ddi_report_dev(ss->ss_dip);
	return (FCOE_SUCCESS);
}

/*
 * Finish final uninitialization
 */
static int
fcoe_detach_uninit(fcoe_soft_state_t *ss)
{
	int ret;
	if (!list_is_empty(&ss->ss_mac_list)) {
		FCOE_LOG("fcoe", "ss_mac_list is not empty when detach");
		return (FCOE_FAILURE);
	}

	if ((ret = fcoe_worker_fini()) != FCOE_SUCCESS) {
		return (ret);
	}

	/*
	 * Stop watchdog
	 */
	if (ss->ss_flags & SS_FLAG_WATCHDOG_RUNNING) {
		mutex_enter(&ss->ss_watch_mutex);
		ss->ss_flags |= SS_FLAG_TERMINATE_WATCHDOG;
		cv_broadcast(&ss->ss_watch_cv);
		mutex_exit(&ss->ss_watch_mutex);
		while (ss->ss_flags & SS_FLAG_WATCHDOG_RUNNING) {
			delay(10);
		}
	}

	ddi_taskq_destroy(ss->ss_watchdog_taskq);
	mutex_destroy(&ss->ss_watch_mutex);
	cv_destroy(&ss->ss_watch_cv);

	ddi_remove_minor_node(ss->ss_dip, NULL);
	mutex_destroy(&ss->ss_ioctl_mutex);
	list_destroy(&ss->ss_mac_list);

	return (FCOE_SUCCESS);
}

/*
 * Return mac instance if it exist, or else return NULL.
 */
fcoe_mac_t *
fcoe_lookup_mac_by_id(datalink_id_t linkid)
{
	fcoe_mac_t	*mac = NULL;

	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));
	for (mac = list_head(&fcoe_global_ss->ss_mac_list); mac;
	    mac = list_next(&fcoe_global_ss->ss_mac_list, mac)) {
		if (linkid != mac->fm_linkid) {
			continue;
		}
		return (mac);
	}
	return (NULL);
}

/*
 * Return B_TRUE if mac exists, or else return B_FALSE
 */
static boolean_t
fcoe_mac_existed(fcoe_mac_t *pmac)
{
	fcoe_mac_t	*mac = NULL;

	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));
	for (mac = list_head(&fcoe_global_ss->ss_mac_list); mac;
	    mac = list_next(&fcoe_global_ss->ss_mac_list, mac)) {
		if (mac == pmac) {
			return (B_TRUE);
		}
	}
	return (B_FALSE);
}

/*
 * port wwn will start with 20:..., node wwn will start with 10:...
 */
static void
fcoe_init_wwn_from_mac(uint8_t *wwn, uint8_t *mac, int is_pwwn, uint8_t idx)
{
	ASSERT(wwn != NULL);
	ASSERT(mac != NULL);
	wwn[0] = (is_pwwn + 1) << 4;
	wwn[1] = idx;
	bcopy(mac, wwn + 2, ETHERADDRL);
}

/*
 * Return fcoe_mac if it exists, otherwise create a new one
 */
static fcoe_mac_t *
fcoe_create_mac_by_id(datalink_id_t linkid)
{
	fcoe_mac_t	*mac = NULL;
	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));

	mac = fcoe_lookup_mac_by_id(linkid);
	if (mac != NULL) {
		FCOE_LOG("fcoe", "fcoe_create_mac_by_id found one mac %d",
		    linkid);
		return (mac);
	}

	mac = kmem_zalloc(sizeof (fcoe_mac_t), KM_SLEEP);
	mac->fm_linkid = linkid;
	mac->fm_flags = 0;
	mac->fm_ss = fcoe_global_ss;
	list_insert_tail(&mac->fm_ss->ss_mac_list, mac);
	FCOE_LOG("fcoe", "fcoe_create_mac_by_id created one mac %d", linkid);
	return (mac);
}

void
fcoe_destroy_mac(fcoe_mac_t *mac)
{
	ASSERT(mac != NULL);
	list_remove(&mac->fm_ss->ss_mac_list, mac);
	kmem_free(mac, sizeof (fcoe_mac_t));
}

/*
 * raw frame layout:
 * ethernet header + vlan header (optional) + FCoE header +
 * FC frame + FCoE tailer
 */
/* ARGSUSED */
mblk_t *
fcoe_get_mblk(fcoe_mac_t *mac, uint32_t raw_frame_size)
{
	mblk_t	*mp;
	int	 err;

	/*
	 * FCFH_SIZE + PADDING_SIZE
	 */
	ASSERT(raw_frame_size >= 60);
	while ((mp = allocb((size_t)raw_frame_size, 0)) == NULL) {
		if ((err = strwaitbuf((size_t)raw_frame_size, BPRI_LO)) != 0) {
			FCOE_LOG("fcoe_get_mblk", "strwaitbuf return %d", err);
			return (NULL);
		}
	}
	mp->b_wptr = mp->b_rptr + raw_frame_size;

	/*
	 * We should always zero FC frame header
	 */
	bzero(mp->b_rptr + PADDING_HEADER_SIZE,
	    sizeof (fcoe_fc_frame_header_t));
	return (mp);
}

static void
fcoe_watchdog(void *arg)
{
	fcoe_soft_state_t	*ss	   = (fcoe_soft_state_t *)arg;
	fcoe_i_frame_t		*fmi;
	fcoe_mac_t		*mac = NULL;

	FCOE_LOG("fcoe", "fcoe_soft_state is %p", ss);

	mutex_enter(&ss->ss_watch_mutex);
	ss->ss_flags |= SS_FLAG_WATCHDOG_RUNNING;
	while ((ss->ss_flags & SS_FLAG_TERMINATE_WATCHDOG) == 0) {
		while (fmi = (fcoe_i_frame_t *)list_head(&ss->ss_pfrm_list)) {
			list_remove(&ss->ss_pfrm_list, fmi);
			mutex_exit(&ss->ss_watch_mutex);

			mac = EPORT2MAC(fmi->fmi_frame->frm_eport);
			mac->fm_client.ect_release_sol_frame(fmi->fmi_frame);

			mutex_enter(&ss->ss_watch_mutex);
			mac->fm_frm_cnt--;
		}

		ss->ss_flags |= SS_FLAG_DOG_WAITING;
		(void) cv_wait(&ss->ss_watch_cv, &ss->ss_watch_mutex);
		ss->ss_flags &= ~SS_FLAG_DOG_WAITING;
	}

	ss->ss_flags &= ~SS_FLAG_WATCHDOG_RUNNING;
	mutex_exit(&ss->ss_watch_mutex);
}

static void
fcoe_worker_init()
{
	uint32_t i;

	fcoe_nworkers_running = 0;
	fcoe_worker_taskq = ddi_taskq_create(0, "FCOE_WORKER_TASKQ",
	    fcoe_nworkers, TASKQ_DEFAULTPRI, 0);
	fcoe_workers = (fcoe_worker_t *)kmem_zalloc(sizeof (fcoe_worker_t) *
	    fcoe_nworkers, KM_SLEEP);
	for (i = 0; i < fcoe_nworkers; i++) {
		fcoe_worker_t *w = &fcoe_workers[i];
		mutex_init(&w->worker_lock, NULL, MUTEX_DRIVER, NULL);
		cv_init(&w->worker_cv, NULL, CV_DRIVER, NULL);
		w->worker_flags &= ~FCOE_WORKER_TERMINATE;
		list_create(&w->worker_frm_list, sizeof (fcoe_i_frame_t),
		    offsetof(fcoe_i_frame_t, fmi_pending_node));
		(void) ddi_taskq_dispatch(fcoe_worker_taskq, fcoe_worker_frame,
		    w, DDI_SLEEP);
	}
	while (fcoe_nworkers_running != fcoe_nworkers) {
		delay(10);
	}
}

static int
fcoe_worker_fini()
{
	uint32_t i;

	for (i = 0; i < fcoe_nworkers; i++) {
		fcoe_worker_t *w = &fcoe_workers[i];
		mutex_enter(&w->worker_lock);
		if (w->worker_flags & FCOE_WORKER_STARTED) {
			w->worker_flags |= FCOE_WORKER_TERMINATE;
			cv_signal(&w->worker_cv);
		}
		mutex_exit(&w->worker_lock);
	}

	while (fcoe_nworkers_running != 0) {
		delay(drv_usectohz(10000));
	}

	ddi_taskq_destroy(fcoe_worker_taskq);
	kmem_free(fcoe_workers, sizeof (fcoe_worker_t) * fcoe_nworkers);
	fcoe_workers = NULL;
	return (FCOE_SUCCESS);
}

static int
fcoe_crc_verify(fcoe_frame_t *frm)
{
	uint32_t crc;
	uint8_t *crc_array = FRM2FMI(frm)->fmi_fft->fft_crc;
	uint32_t crc_from_frame = ~(crc_array[0] | (crc_array[1] << 8) |
	    (crc_array[2] << 16) | (crc_array[3] << 24));
	CRC32(crc, frm->frm_fc_frame, frm->frm_fc_frame_size, -1U, crc32_table);
	return (crc == crc_from_frame ? FCOE_SUCCESS : FCOE_FAILURE);
}

static void
fcoe_worker_frame(void *arg)
{
	fcoe_worker_t	*w = (fcoe_worker_t *)arg;
	fcoe_i_frame_t	*fmi;
	int		ret;

	atomic_inc_32(&fcoe_nworkers_running);
	mutex_enter(&w->worker_lock);
	w->worker_flags |= FCOE_WORKER_STARTED | FCOE_WORKER_ACTIVE;
	while ((w->worker_flags & FCOE_WORKER_TERMINATE) == 0) {
		/*
		 * loop through the frames
		 */
		while (fmi = list_head(&w->worker_frm_list)) {
			list_remove(&w->worker_frm_list, fmi);
			mutex_exit(&w->worker_lock);
			/*
			 * do the checksum
			 */
			ret = fcoe_crc_verify(fmi->fmi_frame);
			if (ret == FCOE_SUCCESS) {
				fmi->fmi_mac->fm_client.ect_rx_frame(
				    fmi->fmi_frame);
			} else {
				fcoe_release_frame(fmi->fmi_frame);
			}
			mutex_enter(&w->worker_lock);
			w->worker_ntasks--;
		}
		w->worker_flags &= ~FCOE_WORKER_ACTIVE;
		cv_wait(&w->worker_cv, &w->worker_lock);
		w->worker_flags |= FCOE_WORKER_ACTIVE;
	}
	w->worker_flags &= ~(FCOE_WORKER_STARTED | FCOE_WORKER_ACTIVE);
	mutex_exit(&w->worker_lock);
	atomic_dec_32(&fcoe_nworkers_running);
	list_destroy(&w->worker_frm_list);
}

void
fcoe_post_frame(fcoe_frame_t *frm)
{
	fcoe_worker_t *w;
	uint16_t	oxid = FRM_OXID(frm);

	w = &fcoe_workers[oxid % fcoe_nworkers_running];
	mutex_enter(&w->worker_lock);
	list_insert_tail(&w->worker_frm_list, frm->frm_fcoe_private);
	w->worker_ntasks++;
	if ((w->worker_flags & FCOE_WORKER_ACTIVE) == 0) {
		cv_signal(&w->worker_cv);
	}
	mutex_exit(&w->worker_lock);
}

/*
 * The max length of every LOG is 158
 */
void
fcoe_trace(caddr_t ident, const char *fmt, ...)
{
	va_list args;
	char	tbuf[160];
	int	len;
	clock_t curclock;
	clock_t usec;

	if (fcoe_trace_on == 0) {
		return;
	}

	curclock = ddi_get_lbolt();
	usec = (curclock - fcoe_trace_start) * usec_per_tick;
	len = snprintf(tbuf, 158, "%lu.%03lus 0t%lu %s ", (usec /
	    (1000 * 1000)), ((usec % (1000 * 1000)) / 1000),
	    curclock, (ident ? ident : "unknown"));
	va_start(args, fmt);
	len += vsnprintf(tbuf + len, 158 - len, fmt, args);
	va_end(args);

	if (len > 158) {
		len = 158;
	}
	tbuf[len++] = '\n';
	tbuf[len] = 0;

	mutex_enter(&fcoe_trace_buf_lock);
	bcopy(tbuf, &fcoe_trace_buf[fcoe_trace_buf_curndx], len+1);
	fcoe_trace_buf_curndx += len;
	if (fcoe_trace_buf_curndx > (fcoe_trace_buf_size - 320)) {
		fcoe_trace_buf_curndx = 0;
	}
	mutex_exit(&fcoe_trace_buf_lock);
}

/*
 * Check whether the pwwn or nwwn already exist or not
 * Return value:
 * 1: PWWN conflicted
 * -1: NWWN conflicted
 * 0: No conflict
 */
static int
fcoe_cmp_wwn(fcoe_mac_t *checkedmac)
{
	fcoe_mac_t	*mac;
	uint8_t		*nwwn, *pwwn, *cnwwn, *cpwwn;

	cnwwn = checkedmac->fm_eport.eport_nodewwn;
	cpwwn = checkedmac->fm_eport.eport_portwwn;
	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));

	for (mac = list_head(&fcoe_global_ss->ss_mac_list); mac;
	    mac = list_next(&fcoe_global_ss->ss_mac_list, mac)) {
		if (mac == checkedmac) {
			continue;
		}
		nwwn = mac->fm_eport.eport_nodewwn;
		pwwn = mac->fm_eport.eport_portwwn;

		if (memcmp(nwwn, cnwwn, 8) == 0) {
			return (-1);
		}

		if (memcmp(pwwn, cpwwn, 8) == 0) {
			return (1);
		}
	}
	return (0);
}

static int
fcoe_get_port_list(fcoe_port_instance_t *ports, int count)
{
	fcoe_mac_t	*mac = NULL;
	int		i = 0;

	ASSERT(ports != NULL);
	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));

	for (mac = list_head(&fcoe_global_ss->ss_mac_list); mac;
	    mac = list_next(&fcoe_global_ss->ss_mac_list, mac)) {
		if (i < count) {
			bcopy(mac->fm_eport.eport_portwwn,
			    ports[i].fpi_pwwn, 8);
			ports[i].fpi_mac_linkid = mac->fm_linkid;
			bcopy(mac->fm_current_addr,
			    ports[i].fpi_mac_current_addr, ETHERADDRL);
			bcopy(mac->fm_primary_addr,
			    ports[i].fpi_mac_factory_addr, ETHERADDRL);
			ports[i].fpi_port_type =
			    EPORT_CLT_TYPE(&mac->fm_eport);
			ports[i].fpi_mtu_size =
			    mac->fm_eport.eport_mtu;
			ports[i].fpi_mac_promisc =
			    mac->fm_promisc_handle != NULL ? 1 : 0;
		}
		i++;
	}
	return (i);
}