/******************************************************************************* * * 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 "tcm_loop.h" #define to_tcm_loop_hba(hba)	container_of(hba, struct tcm_loop_hba, dev) 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); static unsigned int tcm_loop_nr_hw_queues = 1;module_param_named(nr_hw_queues, tcm_loop_nr_hw_queues, uint, 0644); static unsigned int tcm_loop_can_queue = 1024;module_param_named(can_queue, tcm_loop_can_queue, uint, 0644); static unsigned int tcm_loop_cmd_per_lun = 1024;module_param_named(cmd_per_lun, tcm_loop_cmd_per_lun, uint, 0644); /* * Called from struct target_core_fabric_ops->check_stop_free() */static int tcm_loop_check_stop_free(struct se_cmd *se_cmd){	return transport_generic_free_cmd(se_cmd, 0);} 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_puts(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 */static struct device *tcm_loop_primary; 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_tpg->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;	} 	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);	} 	se_cmd->tag = tl_cmd->sc_cmd_tag;	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_SIMPLE_TAG,			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);} /* * ->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("%s() %d:%d:%d:%llu got CDB: 0x%02x scsi_buf_len: %u\n",		 __func__, 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) {		set_host_byte(sc, DID_ERROR);		sc->scsi_done(sc);		return 0;	} 	tl_cmd->sc = sc;	tl_cmd->sc_cmd_tag = sc->request->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,			      u64 lun, int task, enum tcm_tmreq_table tmr){	struct se_cmd *se_cmd;	struct se_session *se_sess;	struct tcm_loop_nexus *tl_nexus;	struct tcm_loop_cmd *tl_cmd;	int ret = TMR_FUNCTION_FAILED, rc; 	/*	 * Locate the tl_nexus and se_sess pointers	 */	tl_nexus = tl_tpg->tl_nexus;	if (!tl_nexus) {		pr_err("Unable to perform device reset without active I_T Nexus\n");		return ret;	} 	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_KERNEL);	if (!tl_cmd)		return ret; 	init_completion(&tl_cmd->tmr_done); 	se_cmd = &tl_cmd->tl_se_cmd;	se_sess = tl_tpg->tl_nexus->se_sess; 	rc = target_submit_tmr(se_cmd, se_sess, tl_cmd->tl_sense_buf, lun,			       NULL, tmr, GFP_KERNEL, task,			       TARGET_SCF_ACK_KREF);	if (rc < 0)		goto release;	wait_for_completion(&tl_cmd->tmr_done);	ret = se_cmd->se_tmr_req->response;	target_put_sess_cmd(se_cmd); out:	return ret; release:	kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);	goto out;} static int tcm_loop_abort_task(struct scsi_cmnd *sc){	struct tcm_loop_hba *tl_hba;	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);	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];	ret = tcm_loop_issue_tmr(tl_tpg, sc->device->lun,				 sc->request->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_tpg *tl_tpg;	int ret = FAILED; 	/*	 * Locate the tcm_loop_hba_t pointer	 */	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id]; 	ret = tcm_loop_issue_tmr(tl_tpg, 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 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	= scsi_change_queue_depth,	.eh_abort_handler = tcm_loop_abort_task,	.eh_device_reset_handler = tcm_loop_device_reset,	.eh_target_reset_handler = tcm_loop_target_reset,	.this_id		= -1,	.sg_tablesize		= 256,	.max_sectors		= 0xFFFF,	.dma_boundary		= PAGE_SIZE - 1,	.module			= THIS_MODULE,	.track_queue_depth	= 1,}; 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;	sh->max_channel = 0;	sh->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE;	sh->nr_hw_queues = tcm_loop_nr_hw_queues;	sh->can_queue = tcm_loop_can_queue;	sh->cmd_per_lun = tcm_loop_cmd_per_lun; 	host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |		    SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |		    SHOST_DIX_TYPE2_PROTECTION | SHOST_DIX_TYPE3_PROTECTION; 	scsi_host_set_prot(sh, host_prot);	scsi_host_set_guard(sh, SHOST_DIX_GUARD_CRC); 	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 inline struct tcm_loop_tpg *tl_tpg(struct se_portal_group *se_tpg){	return container_of(se_tpg, struct tcm_loop_tpg, tl_se_tpg);} static char *tcm_loop_get_endpoint_wwn(struct se_portal_group *se_tpg){	/*	 * Return the passed NAA identifier for the Target Port	 */	return &tl_tpg(se_tpg)->tl_hba->tl_wwn_address[0];} static u16 tcm_loop_get_tag(struct se_portal_group *se_tpg){	/*	 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83	 * to represent the SCSI Target Port.	 */	return tl_tpg(se_tpg)->tl_tpgt;} /* * Returning (1) here allows for target_core_mod struct se_node_acl to be generated * based upon the incoming fabric dependent SCSI Initiator Port */static int tcm_loop_check_demo_mode(struct se_portal_group *se_tpg){	return 1;} static int tcm_loop_check_demo_mode_cache(struct se_portal_group *se_tpg){	return 0;} /* * Allow I_T Nexus full READ-WRITE access without explict Initiator Node ACLs for * local virtual Linux/SCSI LLD passthrough into VM hypervisor guest */static int tcm_loop_check_demo_mode_write_protect(struct se_portal_group *se_tpg){	return 0;

Lines 1–500 of 1212. Load more