/******************************************************************************* * * 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;} /* * 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;	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;	} 	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; 	}	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,			scsi_bufflen(sc), tcm_loop_sam_attr(sc),			sc->sc_data_direction, 0,			scsi_sglist(sc), scsi_sg_count(sc),			sgl_bidi, sgl_bidi_count);	if (rc < 0) {		set_host_byte(sc, DID_NO_CONNECT);		goto out_done;	}	return; out_done:	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;	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_device_reset(struct scsi_cmnd *sc){	struct se_cmd *se_cmd = NULL;	struct se_portal_group *se_tpg;	struct se_session *se_sess;	struct tcm_loop_cmd *tl_cmd = NULL;	struct tcm_loop_hba *tl_hba;	struct tcm_loop_nexus *tl_nexus;	struct tcm_loop_tmr *tl_tmr = NULL;	struct tcm_loop_tpg *tl_tpg;	int ret = FAILED, rc;	/*	 * 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;	}	se_sess = tl_nexus->se_sess;	/*	 * Locate the tl_tpg and se_tpg pointers from TargetID in sc->device->id	 */	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];	se_tpg = &tl_tpg->tl_se_tpg; 	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 FAILED;	} 	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;	/*	 * 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_LUN_RESET, GFP_KERNEL);	if (rc < 0)		goto release;	/*	 * Locate the underlying TCM struct se_lun from sc->device->lun	 */	if (transport_lookup_tmr_lun(se_cmd, sc->device->lun) < 0)		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 == TMR_FUNCTION_COMPLETE) ?		SUCCESS : FAILED;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_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){	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,	.eh_device_reset_handler = tcm_loop_device_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; 	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;	sh->max_channel = 0;	sh->max_cmd_len = TL_SCSI_MAX_CMD_LEN; 	error = scsi_add_host(sh, &tl_hba->dev);	if (error) {		pr_err("%s: scsi_add_host failed\n", __func__);		scsi_host_put(sh);		return -ENODEV;	}	return 0;} static int tcm_loop_driver_remove(struct device *dev){	struct tcm_loop_hba *tl_hba;	struct Scsi_Host *sh; 	tl_hba = to_tcm_loop_hba(dev);	sh = tl_hba->sh; 	scsi_remove_host(sh);	scsi_host_put(sh);	return 0;} static void tcm_loop_release_adapter(struct device *dev){	struct tcm_loop_hba *tl_hba = to_tcm_loop_hba(dev); 	kfree(tl_hba);} /* * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c */static int tcm_loop_setup_hba_bus(struct tcm_loop_hba *tl_hba, int tcm_loop_host_id){	int ret; 	tl_hba->dev.bus = &tcm_loop_lld_bus;	tl_hba->dev.parent = tcm_loop_primary;	tl_hba->dev.release = &tcm_loop_release_adapter;	dev_set_name(&tl_hba->dev, "tcm_loop_adapter_%d", tcm_loop_host_id); 	ret = device_register(&tl_hba->dev);	if (ret) {		pr_err("device_register() failed for"				" tl_hba->dev: %d\n", ret);		return -ENODEV;	} 	return 0;} /* * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated * tcm_loop SCSI bus. */static int tcm_loop_alloc_core_bus(void){	int ret; 	tcm_loop_primary = root_device_register("tcm_loop_0");	if (IS_ERR(tcm_loop_primary)) {		pr_err("Unable to allocate tcm_loop_primary\n");		return PTR_ERR(tcm_loop_primary);	} 	ret = bus_register(&tcm_loop_lld_bus);	if (ret) {		pr_err("bus_register() failed for tcm_loop_lld_bus\n");		goto dev_unreg;	} 	ret = driver_register(&tcm_loop_driverfs);	if (ret) {		pr_err("driver_register() failed for"				"tcm_loop_driverfs\n");		goto bus_unreg;	} 	pr_debug("Initialized TCM Loop Core Bus\n");	return ret; bus_unreg:	bus_unregister(&tcm_loop_lld_bus);dev_unreg:	root_device_unregister(tcm_loop_primary);	return ret;} static void tcm_loop_release_core_bus(void){	driver_unregister(&tcm_loop_driverfs);	bus_unregister(&tcm_loop_lld_bus);	root_device_unregister(tcm_loop_primary); 	pr_debug("Releasing TCM Loop Core BUS\n");} static char *tcm_loop_get_fabric_name(void){	return "loopback";} static u8 tcm_loop_get_fabric_proto_ident(struct se_portal_group *se_tpg){	struct tcm_loop_tpg *tl_tpg = se_tpg->se_tpg_fabric_ptr;	struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;	/*	 * tl_proto_id is set at tcm_loop_configfs.c:tcm_loop_make_scsi_hba()	 * time based on the protocol dependent prefix of the passed configfs group.	 *	 * Based upon tl_proto_id, TCM_Loop emulates the requested fabric	 * ProtocolID using target_core_fabric_lib.c symbols.	 */	switch (tl_hba->tl_proto_id) {	case SCSI_PROTOCOL_SAS:		return sas_get_fabric_proto_ident(se_tpg);	case SCSI_PROTOCOL_FCP:		return fc_get_fabric_proto_ident(se_tpg);

Lines 1–500 of 1423. Load more