/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2017, Joyent, Inc.
 */

#include <sys/scsi/adapters/smrt/smrt.h>

static void
smrt_logvol_free(smrt_volume_t *smlv)
{
	/*
	 * By this stage of teardown, all of the SCSI target drivers
	 * must have been detached from this logical volume.
	 */
	VERIFY(list_is_empty(&smlv->smlv_targets));
	list_destroy(&smlv->smlv_targets);

	kmem_free(smlv, sizeof (*smlv));
}

smrt_volume_t *
smrt_logvol_lookup_by_id(smrt_t *smrt, unsigned long id)
{
	VERIFY(MUTEX_HELD(&smrt->smrt_mutex));

	for (smrt_volume_t *smlv = list_head(&smrt->smrt_volumes);
	    smlv != NULL; smlv = list_next(&smrt->smrt_volumes, smlv)) {
		if (smlv->smlv_addr.LogDev.VolId == id) {
			return (smlv);
		}
	}

	return (NULL);
}

static int
smrt_read_logvols(smrt_t *smrt, smrt_report_logical_lun_t *smrll, uint64_t gen)
{
	smrt_report_logical_lun_ent_t *ents = smrll->smrll_data.ents;
	uint32_t count = BE_32(smrll->smrll_datasize) /
	    sizeof (smrt_report_logical_lun_ent_t);

	VERIFY(MUTEX_HELD(&smrt->smrt_mutex));

	if (count > SMRT_MAX_LOGDRV) {
		count = SMRT_MAX_LOGDRV;
	}

	for (unsigned i = 0; i < count; i++) {
		smrt_volume_t *smlv;
		char id[SCSI_MAXNAMELEN];

		DTRACE_PROBE2(read_logvol, unsigned, i,
		    smrt_report_logical_lun_ent_t *, &ents[i]);

		if ((smlv = smrt_logvol_lookup_by_id(smrt,
		    ents[i].smrle_addr.VolId)) == NULL) {

			/*
			 * This is a new Logical Volume, so add it the the list.
			 */
			if ((smlv = kmem_zalloc(sizeof (*smlv), KM_NOSLEEP)) ==
			    NULL) {
				return (ENOMEM);
			}

			list_create(&smlv->smlv_targets,
			    sizeof (smrt_target_t),
			    offsetof(smrt_target_t, smtg_link_lun));

			smlv->smlv_ctlr = smrt;
			list_insert_tail(&smrt->smrt_volumes, smlv);
		}

		/*
		 * Always make sure that the address and the generation are up
		 * to date, regardless of where this came from.
		 */
		smlv->smlv_addr.LogDev = ents[i].smrle_addr;
		smlv->smlv_gen = gen;
		(void) snprintf(id, sizeof (id), "%x",
		    smlv->smlv_addr.LogDev.VolId);
		if (!ddi_in_panic() &&
		    scsi_hba_tgtmap_set_add(smrt->smrt_virt_tgtmap,
		    SCSI_TGT_SCSI_DEVICE, id, NULL) != DDI_SUCCESS) {
			return (EIO);
		}
	}

	return (0);
}

static int
smrt_read_logvols_ext(smrt_t *smrt, smrt_report_logical_lun_t *smrll,
    uint64_t gen)
{
	smrt_report_logical_lun_extent_t *extents =
	    smrll->smrll_data.extents;
	uint32_t count = BE_32(smrll->smrll_datasize) /
	    sizeof (smrt_report_logical_lun_extent_t);

	VERIFY(MUTEX_HELD(&smrt->smrt_mutex));

	if (count > SMRT_MAX_LOGDRV) {
		count = SMRT_MAX_LOGDRV;
	}

	for (unsigned i = 0; i < count; i++) {
		smrt_volume_t *smlv;
		char id[SCSI_MAXNAMELEN];

		DTRACE_PROBE2(read_logvol_ext, unsigned, i,
		    smrt_report_logical_lun_extent_t *, &extents[i]);

		if ((smlv = smrt_logvol_lookup_by_id(smrt,
		    extents[i].smrle_addr.VolId)) != NULL) {
			if ((smlv->smlv_flags & SMRT_VOL_FLAG_WWN) &&
			    bcmp(extents[i].smrle_wwn, smlv->smlv_wwn,
			    16) != 0) {
				dev_err(smrt->smrt_dip, CE_PANIC, "logical "
				    "volume %u WWN changed unexpectedly", i);
			}
		} else {
			/*
			 * This is a new Logical Volume, so add it the the list.
			 */
			if ((smlv = kmem_zalloc(sizeof (*smlv), KM_NOSLEEP)) ==
			    NULL) {
				return (ENOMEM);
			}

			bcopy(extents[i].smrle_wwn, smlv->smlv_wwn, 16);
			smlv->smlv_flags |= SMRT_VOL_FLAG_WWN;

			list_create(&smlv->smlv_targets,
			    sizeof (smrt_target_t),
			    offsetof(smrt_target_t, smtg_link_lun));

			smlv->smlv_ctlr = smrt;
			list_insert_tail(&smrt->smrt_volumes, smlv);
		}

		/*
		 * Always make sure that the address and the generation are up
		 * to date.  The address may have changed on a reset.
		 */
		smlv->smlv_addr.LogDev = extents[i].smrle_addr;
		smlv->smlv_gen = gen;
		(void) snprintf(id, sizeof (id), "%x",
		    smlv->smlv_addr.LogDev.VolId);
		if (!ddi_in_panic() &&
		    scsi_hba_tgtmap_set_add(smrt->smrt_virt_tgtmap,
		    SCSI_TGT_SCSI_DEVICE, id, NULL) != DDI_SUCCESS) {
			return (EIO);
		}
	}

	return (0);
}

/*
 * Discover the currently visible set of Logical Volumes exposed by the
 * controller.
 */
int
smrt_logvol_discover(smrt_t *smrt, uint16_t timeout, uint64_t gen)
{
	smrt_command_t *smcm;
	smrt_report_logical_lun_t *smrll;
	smrt_report_logical_lun_req_t smrllr = { 0 };
	int r;

	/*
	 * Allocate the command to send to the device, including buffer space
	 * for the returned list of Logical Volumes.
	 */
	if ((smcm = smrt_command_alloc(smrt, SMRT_CMDTYPE_INTERNAL,
	    KM_NOSLEEP)) == NULL || smrt_command_attach_internal(smrt, smcm,
	    sizeof (smrt_report_logical_lun_t), KM_NOSLEEP) != 0) {
		r = ENOMEM;
		mutex_enter(&smrt->smrt_mutex);
		goto out;
	}

	smrll = smcm->smcm_internal->smcmi_va;

	smrt_write_controller_lun_addr(&smcm->smcm_va_cmd->Header.LUN);

	smcm->smcm_va_cmd->Request.CDBLen = sizeof (smrllr);
	smcm->smcm_va_cmd->Request.Timeout = LE_16(timeout);
	smcm->smcm_va_cmd->Request.Type.Type = CISS_TYPE_CMD;
	smcm->smcm_va_cmd->Request.Type.Attribute = CISS_ATTR_SIMPLE;
	smcm->smcm_va_cmd->Request.Type.Direction = CISS_XFER_READ;

	/*
	 * The Report Logical LUNs command is essentially a vendor-specific
	 * SCSI command, which we assemble into the CDB region of the command
	 * block.
	 */
	bzero(&smrllr, sizeof (smrllr));
	smrllr.smrllr_opcode = CISS_SCMD_REPORT_LOGICAL_LUNS;
	smrllr.smrllr_extflag = 1;
	smrllr.smrllr_datasize = htonl(sizeof (smrt_report_logical_lun_t));
	bcopy(&smrllr, &smcm->smcm_va_cmd->Request.CDB[0],
	    MIN(CISS_CDBLEN, sizeof (smrllr)));

	mutex_enter(&smrt->smrt_mutex);

	/*
	 * Send the command to the device.
	 */
	smcm->smcm_status |= SMRT_CMD_STATUS_POLLED;
	if ((r = smrt_submit(smrt, smcm)) != 0) {
		goto out;
	}

	/*
	 * Poll for completion.
	 */
	smcm->smcm_expiry = gethrtime() + timeout * NANOSEC;
	if ((r = smrt_poll_for(smrt, smcm)) != 0) {
		VERIFY3S(r, ==, ETIMEDOUT);
		VERIFY0(smcm->smcm_status & SMRT_CMD_STATUS_POLL_COMPLETE);

		/*
		 * The command timed out; abandon it now.  Remove the POLLED
		 * flag so that the periodic routine will send an abort to
		 * clean it up next time around.
		 */
		smcm->smcm_status |= SMRT_CMD_STATUS_ABANDONED;
		smcm->smcm_status &= ~SMRT_CMD_STATUS_POLLED;
		smcm = NULL;
		goto out;
	}

	if (smcm->smcm_status & SMRT_CMD_STATUS_RESET_SENT) {
		/*
		 * The controller was reset while we were trying to discover
		 * logical volumes.  Report failure.
		 */
		r = EIO;
		goto out;
	}

	if (smcm->smcm_status & SMRT_CMD_STATUS_ERROR) {
		ErrorInfo_t *ei = smcm->smcm_va_err;

		if (ei->CommandStatus != CISS_CMD_DATA_UNDERRUN) {
			dev_err(smrt->smrt_dip, CE_WARN, "logical volume "
			    "discovery error: status 0x%x", ei->CommandStatus);
			r = EIO;
			goto out;
		}
	}

	if (!ddi_in_panic() &&
	    scsi_hba_tgtmap_set_begin(smrt->smrt_virt_tgtmap) != DDI_SUCCESS) {
		dev_err(smrt->smrt_dip, CE_WARN, "failed to begin target map "
		    "observation on %s", SMRT_IPORT_VIRT);
		r = EIO;
		goto out;
	}

	if ((smrll->smrll_extflag & 0x1) != 0) {
		r = smrt_read_logvols_ext(smrt, smrll, gen);
	} else {
		r = smrt_read_logvols(smrt, smrll, gen);
	}

	if (r == 0 && !ddi_in_panic()) {
		if (scsi_hba_tgtmap_set_end(smrt->smrt_virt_tgtmap, 0) !=
		    DDI_SUCCESS) {
			dev_err(smrt->smrt_dip, CE_WARN, "failed to end target "
			    "map observation on %s", SMRT_IPORT_VIRT);
			r = EIO;
		}
	} else if (r != 0 && !ddi_in_panic()) {
		if (scsi_hba_tgtmap_set_flush(smrt->smrt_virt_tgtmap) !=
		    DDI_SUCCESS) {
			dev_err(smrt->smrt_dip, CE_WARN, "failed to end target "
			    "map observation on %s", SMRT_IPORT_VIRT);
			r = EIO;
		}
	}

	if (r == 0) {
		/*
		 * Update the time of the last successful Logical Volume
		 * discovery:
		 */
		smrt->smrt_last_log_discovery = gethrtime();
	}

out:
	mutex_exit(&smrt->smrt_mutex);

	if (smcm != NULL) {
		smrt_command_free(smcm);
	}
	return (r);
}

void
smrt_logvol_tgtmap_activate(void *arg, char *addr, scsi_tgtmap_tgt_type_t type,
    void **privpp)
{
	smrt_t *smrt = arg;
	unsigned long volume;
	char *eptr;

	VERIFY(type == SCSI_TGT_SCSI_DEVICE);
	VERIFY0(ddi_strtoul(addr, &eptr, 16, &volume));
	VERIFY3S(*eptr, ==, '\0');
	VERIFY3S(volume, >=, 0);
	VERIFY3S(volume, <, SMRT_MAX_LOGDRV);
	mutex_enter(&smrt->smrt_mutex);
	VERIFY(smrt_logvol_lookup_by_id(smrt, volume) != NULL);
	mutex_exit(&smrt->smrt_mutex);
	*privpp = NULL;
}

boolean_t
smrt_logvol_tgtmap_deactivate(void *arg, char *addr,
    scsi_tgtmap_tgt_type_t type, void *priv, scsi_tgtmap_deact_rsn_t reason)
{
	smrt_t *smrt = arg;
	smrt_volume_t *smlv;
	unsigned long volume;
	char *eptr;

	VERIFY(type == SCSI_TGT_SCSI_DEVICE);
	VERIFY(priv == NULL);
	VERIFY0(ddi_strtoul(addr, &eptr, 16, &volume));
	VERIFY3S(*eptr, ==, '\0');
	VERIFY3S(volume, >=, 0);
	VERIFY3S(volume, <, SMRT_MAX_LOGDRV);

	mutex_enter(&smrt->smrt_mutex);
	smlv = smrt_logvol_lookup_by_id(smrt, volume);
	VERIFY(smlv != NULL);

	list_remove(&smrt->smrt_volumes, smlv);
	smrt_logvol_free(smlv);
	mutex_exit(&smrt->smrt_mutex);

	return (B_FALSE);
}

void
smrt_logvol_teardown(smrt_t *smrt)
{
	smrt_volume_t *smlv;

	while ((smlv = list_remove_head(&smrt->smrt_volumes)) != NULL) {
		smrt_logvol_free(smlv);
	}
}