/******************************************************************************* * * This file contains the Linux/SCSI LLD virtual SCSI initiator driver * for emulated SAS initiator ports * * © Copyright 2011-2013 Datera, Inc. * * Licensed to the Linux Foundation under the General Public License (GPL) version 2. * * Author: Nicholas A. Bellinger <nab@risingtidesystems.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. ****************************************************************************/ #include <linux/module.h>#include <linux/moduleparam.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/types.h>#include <linux/configfs.h>#include <scsi/scsi.h>#include <scsi/scsi_tcq.h>#include <scsi/scsi_host.h>#include <scsi/scsi_device.h>#include <scsi/scsi_cmnd.h> #include <target/target_core_base.h>#include <target/target_core_fabric.h>#include <target/target_core_fabric_configfs.h>#include <target/target_core_configfs.h> #include "tcm_loop.h" #define to_tcm_loop_hba(hba)	container_of(hba, struct tcm_loop_hba, dev) /* Local pointer to allocated TCM configfs fabric module */static struct target_fabric_configfs *tcm_loop_fabric_configfs; static struct workqueue_struct *tcm_loop_workqueue;static struct kmem_cache *tcm_loop_cmd_cache; static int tcm_loop_hba_no_cnt; static int tcm_loop_queue_status(struct se_cmd *se_cmd); /* * Called from struct target_core_fabric_ops->check_stop_free() */static int tcm_loop_check_stop_free(struct se_cmd *se_cmd){	/*	 * Do not release struct se_cmd's containing a valid TMR	 * pointer.  These will be released directly in tcm_loop_device_reset()	 * with transport_generic_free_cmd().	 */	if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)		return 0;	/*	 * Release the struct se_cmd, which will make a callback to release	 * struct tcm_loop_cmd * in tcm_loop_deallocate_core_cmd()	 */	transport_generic_free_cmd(se_cmd, 0);	return 1;} static void tcm_loop_release_cmd(struct se_cmd *se_cmd){	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,				struct tcm_loop_cmd, tl_se_cmd); 	kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);} static int tcm_loop_show_info(struct seq_file *m, struct Scsi_Host *host){	seq_printf(m, "tcm_loop_proc_info()\n");	return 0;} static int tcm_loop_driver_probe(struct device *);static int tcm_loop_driver_remove(struct device *); static int pseudo_lld_bus_match(struct device *dev,				struct device_driver *dev_driver){	return 1;} static struct bus_type tcm_loop_lld_bus = {	.name			= "tcm_loop_bus",	.match			= pseudo_lld_bus_match,	.probe			= tcm_loop_driver_probe,	.remove			= tcm_loop_driver_remove,}; static struct device_driver tcm_loop_driverfs = {	.name			= "tcm_loop",	.bus			= &tcm_loop_lld_bus,};/* * Used with root_device_register() in tcm_loop_alloc_core_bus() below */struct device *tcm_loop_primary; /* * Copied from drivers/scsi/libfc/fc_fcp.c:fc_change_queue_depth() and * drivers/scsi/libiscsi.c:iscsi_change_queue_depth() */static int tcm_loop_change_queue_depth(	struct scsi_device *sdev,	int depth,	int reason){	switch (reason) {	case SCSI_QDEPTH_DEFAULT:		scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);		break;	case SCSI_QDEPTH_QFULL:		scsi_track_queue_full(sdev, depth);		break;	case SCSI_QDEPTH_RAMP_UP:		scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);		break;	default:		return -EOPNOTSUPP;	}	return sdev->queue_depth;} static int tcm_loop_change_queue_type(struct scsi_device *sdev, int tag){	if (sdev->tagged_supported) {		scsi_set_tag_type(sdev, tag); 		if (tag)			scsi_activate_tcq(sdev, sdev->queue_depth);		else			scsi_deactivate_tcq(sdev, sdev->queue_depth);	} else		tag = 0; 	return tag;} /* * Locate the SAM Task Attr from struct scsi_cmnd * */static int tcm_loop_sam_attr(struct scsi_cmnd *sc){	if (sc->device->tagged_supported) {		switch (sc->tag) {		case HEAD_OF_QUEUE_TAG:			return MSG_HEAD_TAG;		case ORDERED_QUEUE_TAG:			return MSG_ORDERED_TAG;		default:			break;		}	} 	return MSG_SIMPLE_TAG;} static void tcm_loop_submission_work(struct work_struct *work){	struct tcm_loop_cmd *tl_cmd =		container_of(work, struct tcm_loop_cmd, work);	struct se_cmd *se_cmd = &tl_cmd->tl_se_cmd;	struct scsi_cmnd *sc = tl_cmd->sc;	struct tcm_loop_nexus *tl_nexus;	struct tcm_loop_hba *tl_hba;	struct tcm_loop_tpg *tl_tpg;	struct scatterlist *sgl_bidi = NULL;	u32 sgl_bidi_count = 0, transfer_length;	int rc; 	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id]; 	/*	 * Ensure that this tl_tpg reference from the incoming sc->device->id	 * has already been configured via tcm_loop_make_naa_tpg().	 */	if (!tl_tpg->tl_hba) {		set_host_byte(sc, DID_NO_CONNECT);		goto out_done;	}	if (tl_tpg->tl_transport_status == TCM_TRANSPORT_OFFLINE) {		set_host_byte(sc, DID_TRANSPORT_DISRUPTED);		goto out_done;	}	tl_nexus = tl_hba->tl_nexus;	if (!tl_nexus) {		scmd_printk(KERN_ERR, sc, "TCM_Loop I_T Nexus"				" does not exist\n");		set_host_byte(sc, DID_ERROR);		goto out_done;	}	if (scsi_bidi_cmnd(sc)) {		struct scsi_data_buffer *sdb = scsi_in(sc); 		sgl_bidi = sdb->table.sgl;		sgl_bidi_count = sdb->table.nents;		se_cmd->se_cmd_flags |= SCF_BIDI; 	} 	transfer_length = scsi_transfer_length(sc);	if (!scsi_prot_sg_count(sc) &&	    scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) {		se_cmd->prot_pto = true;		/*		 * loopback transport doesn't support		 * WRITE_GENERATE, READ_STRIP protection		 * information operations, go ahead unprotected.		 */		transfer_length = scsi_bufflen(sc);	} 	rc = target_submit_cmd_map_sgls(se_cmd, tl_nexus->se_sess, sc->cmnd,			&tl_cmd->tl_sense_buf[0], tl_cmd->sc->device->lun,			transfer_length, tcm_loop_sam_attr(sc),			sc->sc_data_direction, 0,			scsi_sglist(sc), scsi_sg_count(sc),			sgl_bidi, sgl_bidi_count,			scsi_prot_sglist(sc), scsi_prot_sg_count(sc));	if (rc < 0) {		set_host_byte(sc, DID_NO_CONNECT);		goto out_done;	}	return; out_done:	kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);	sc->scsi_done(sc);	return;} /* * ->queuecommand can be and usually is called from interrupt context, so * defer the actual submission to a workqueue. */static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc){	struct tcm_loop_cmd *tl_cmd; 	pr_debug("tcm_loop_queuecommand() %d:%d:%d:%d got CDB: 0x%02x"		" scsi_buf_len: %u\n", sc->device->host->host_no,		sc->device->id, sc->device->channel, sc->device->lun,		sc->cmnd[0], scsi_bufflen(sc)); 	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_ATOMIC);	if (!tl_cmd) {		pr_err("Unable to allocate struct tcm_loop_cmd\n");		set_host_byte(sc, DID_ERROR);		sc->scsi_done(sc);		return 0;	} 	tl_cmd->sc = sc;	tl_cmd->sc_cmd_tag = sc->tag;	INIT_WORK(&tl_cmd->work, tcm_loop_submission_work);	queue_work(tcm_loop_workqueue, &tl_cmd->work);	return 0;} /* * Called from SCSI EH process context to issue a LUN_RESET TMR * to struct scsi_device */static int tcm_loop_issue_tmr(struct tcm_loop_tpg *tl_tpg,			      struct tcm_loop_nexus *tl_nexus,			      int lun, int task, enum tcm_tmreq_table tmr){	struct se_cmd *se_cmd = NULL;	struct se_session *se_sess;	struct se_portal_group *se_tpg;	struct tcm_loop_cmd *tl_cmd = NULL;	struct tcm_loop_tmr *tl_tmr = NULL;	int ret = TMR_FUNCTION_FAILED, rc; 	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_KERNEL);	if (!tl_cmd) {		pr_err("Unable to allocate memory for tl_cmd\n");		return ret;	} 	tl_tmr = kzalloc(sizeof(struct tcm_loop_tmr), GFP_KERNEL);	if (!tl_tmr) {		pr_err("Unable to allocate memory for tl_tmr\n");		goto release;	}	init_waitqueue_head(&tl_tmr->tl_tmr_wait); 	se_cmd = &tl_cmd->tl_se_cmd;	se_tpg = &tl_tpg->tl_se_tpg;	se_sess = tl_nexus->se_sess;	/*	 * Initialize struct se_cmd descriptor from target_core_mod infrastructure	 */	transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0,				DMA_NONE, MSG_SIMPLE_TAG,				&tl_cmd->tl_sense_buf[0]); 	rc = core_tmr_alloc_req(se_cmd, tl_tmr, tmr, GFP_KERNEL);	if (rc < 0)		goto release; 	if (tmr == TMR_ABORT_TASK)		se_cmd->se_tmr_req->ref_task_tag = task; 	/*	 * Locate the underlying TCM struct se_lun	 */	if (transport_lookup_tmr_lun(se_cmd, lun) < 0) {		ret = TMR_LUN_DOES_NOT_EXIST;		goto release;	}	/*	 * Queue the TMR to TCM Core and sleep waiting for	 * tcm_loop_queue_tm_rsp() to wake us up.	 */	transport_generic_handle_tmr(se_cmd);	wait_event(tl_tmr->tl_tmr_wait, atomic_read(&tl_tmr->tmr_complete));	/*	 * The TMR LUN_RESET has completed, check the response status and	 * then release allocations.	 */	ret = se_cmd->se_tmr_req->response;release:	if (se_cmd)		transport_generic_free_cmd(se_cmd, 1);	else		kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);	kfree(tl_tmr);	return ret;} static int tcm_loop_abort_task(struct scsi_cmnd *sc){	struct tcm_loop_hba *tl_hba;	struct tcm_loop_nexus *tl_nexus;	struct tcm_loop_tpg *tl_tpg;	int ret = FAILED; 	/*	 * Locate the tcm_loop_hba_t pointer	 */	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);	/*	 * Locate the tl_nexus and se_sess pointers	 */	tl_nexus = tl_hba->tl_nexus;	if (!tl_nexus) {		pr_err("Unable to perform device reset without"				" active I_T Nexus\n");		return FAILED;	} 	/*	 * Locate the tl_tpg pointer from TargetID in sc->device->id	 */	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];	ret = tcm_loop_issue_tmr(tl_tpg, tl_nexus, sc->device->lun,				 sc->tag, TMR_ABORT_TASK);	return (ret == TMR_FUNCTION_COMPLETE) ? SUCCESS : FAILED;} /* * Called from SCSI EH process context to issue a LUN_RESET TMR * to struct scsi_device */static int tcm_loop_device_reset(struct scsi_cmnd *sc){	struct tcm_loop_hba *tl_hba;	struct tcm_loop_nexus *tl_nexus;	struct tcm_loop_tpg *tl_tpg;	int ret = FAILED; 	/*	 * Locate the tcm_loop_hba_t pointer	 */	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);	/*	 * Locate the tl_nexus and se_sess pointers	 */	tl_nexus = tl_hba->tl_nexus;	if (!tl_nexus) {		pr_err("Unable to perform device reset without"				" active I_T Nexus\n");		return FAILED;	}	/*	 * Locate the tl_tpg pointer from TargetID in sc->device->id	 */	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];	ret = tcm_loop_issue_tmr(tl_tpg, tl_nexus, sc->device->lun,				 0, TMR_LUN_RESET);	return (ret == TMR_FUNCTION_COMPLETE) ? SUCCESS : FAILED;} static int tcm_loop_target_reset(struct scsi_cmnd *sc){	struct tcm_loop_hba *tl_hba;	struct tcm_loop_tpg *tl_tpg; 	/*	 * Locate the tcm_loop_hba_t pointer	 */	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);	if (!tl_hba) {		pr_err("Unable to perform device reset without"				" active I_T Nexus\n");		return FAILED;	}	/*	 * Locate the tl_tpg pointer from TargetID in sc->device->id	 */	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];	if (tl_tpg) {		tl_tpg->tl_transport_status = TCM_TRANSPORT_ONLINE;		return SUCCESS;	}	return FAILED;} static int tcm_loop_slave_alloc(struct scsi_device *sd){	set_bit(QUEUE_FLAG_BIDI, &sd->request_queue->queue_flags);	return 0;} static int tcm_loop_slave_configure(struct scsi_device *sd){	if (sd->tagged_supported) {		scsi_activate_tcq(sd, sd->queue_depth);		scsi_adjust_queue_depth(sd, MSG_SIMPLE_TAG,					sd->host->cmd_per_lun);	} else {		scsi_adjust_queue_depth(sd, 0,					sd->host->cmd_per_lun);	} 	return 0;} static struct scsi_host_template tcm_loop_driver_template = {	.show_info		= tcm_loop_show_info,	.proc_name		= "tcm_loopback",	.name			= "TCM_Loopback",	.queuecommand		= tcm_loop_queuecommand,	.change_queue_depth	= tcm_loop_change_queue_depth,	.change_queue_type	= tcm_loop_change_queue_type,	.eh_abort_handler = tcm_loop_abort_task,	.eh_device_reset_handler = tcm_loop_device_reset,	.eh_target_reset_handler = tcm_loop_target_reset,	.can_queue		= 1024,	.this_id		= -1,	.sg_tablesize		= 256,	.cmd_per_lun		= 1024,	.max_sectors		= 0xFFFF,	.use_clustering		= DISABLE_CLUSTERING,	.slave_alloc		= tcm_loop_slave_alloc,	.slave_configure	= tcm_loop_slave_configure,	.module			= THIS_MODULE,}; static int tcm_loop_driver_probe(struct device *dev){	struct tcm_loop_hba *tl_hba;	struct Scsi_Host *sh;	int error, host_prot; 	tl_hba = to_tcm_loop_hba(dev); 	sh = scsi_host_alloc(&tcm_loop_driver_template,			sizeof(struct tcm_loop_hba));	if (!sh) {		pr_err("Unable to allocate struct scsi_host\n");		return -ENODEV;	}	tl_hba->sh = sh; 	/*	 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata	 */	*((struct tcm_loop_hba **)sh->hostdata) = tl_hba;	/*	 * Setup single ID, Channel and LUN for now..	 */	sh->max_id = 2;	sh->max_lun = 0;

Lines 1–500 of 1611. Load more