Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 72f96e0e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus-core' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending 

* 'for-linus-core' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (38 commits)
  target: Bump version to v4.1.0-rc1-ml
  target: remove custom hex2bin() implementation
  target: fix typo Assoication -> Association
  target: Update QUEUE ALGORITHM MODIFIER control page default
  target: ->map_task_SG conversion to ->map_control_SG and ->map_data_SG
  target: Follow up core updates from AGrover and HCH (round 4)
  target: Eliminate usage of struct se_mem
  target: Pass 2nd param of transport_split_cdb by value
  target: Enforce 1 page max for control cdb buffer sizes
  target: Make all control CDBs scatter-gather
  target: Implement Block Device Characteristics VPD page
  target: Fix reporting of supported VPD pages
  target: Allow for built-in target modules
  tcm_fc: Convert to wake_up_process and schedule_timeout_interruptible
  tcm_fc: Makefile cleanups
  loopback: Fix memory leak in tcm_loop_make_scsi_hba()
  loopback: Remove duplicate scsi/scsi_tcq.h include
  loopback: off by one in tcm_loop_make_naa_tpg()
  target/iblock: Remove unused iblock_dev members
  target/iblock: Use request_queue->nr_request for se_device defaults
  ...
parents 17413f5a fa495159

drivers/target/loopback/Kconfig

+0 −6
Original line number Diff line number Diff line
@@ -3,9 +3,3 @@ config LOOPBACK_TARGET 
	help

	  Say Y here to enable the TCM Virtual SAS target and Linux/SCSI LLD

	  fabric loopback module.
 


config LOOPBACK_TARGET_CDB_DEBUG

	bool "TCM loopback fabric module CDB debug code"

	depends on LOOPBACK_TARGET

	help

	  Say Y here to enable the TCM loopback fabric module CDB debug code

drivers/target/loopback/tcm_loop.c

+84 −123
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ 
#include <scsi/scsi_host.h>

#include <scsi/scsi_device.h>

#include <scsi/scsi_cmnd.h>

#include <scsi/scsi_tcq.h>



#include <target/target_core_base.h>

#include <target/target_core_transport.h>
@@ -80,7 +79,7 @@ static struct se_cmd *tcm_loop_allocate_core_cmd( 


	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_ATOMIC);

	if (!tl_cmd) {

		printk(KERN_ERR "Unable to allocate struct tcm_loop_cmd\n");

		pr_err("Unable to allocate struct tcm_loop_cmd\n");

		set_host_byte(sc, DID_ERROR);

		return NULL;

	}
@@ -118,17 +117,16 @@ static struct se_cmd *tcm_loop_allocate_core_cmd( 
	 * Signal BIDI usage with T_TASK(cmd)->t_tasks_bidi

	 */

	if (scsi_bidi_cmnd(sc))

		T_TASK(se_cmd)->t_tasks_bidi = 1;

		se_cmd->t_tasks_bidi = 1;

	/*

	 * Locate the struct se_lun pointer and attach it to struct se_cmd

	 */

	if (transport_get_lun_for_cmd(se_cmd, NULL, tl_cmd->sc->device->lun) < 0) {

	if (transport_lookup_cmd_lun(se_cmd, tl_cmd->sc->device->lun) < 0) {

		kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);

		set_host_byte(sc, DID_NO_CONNECT);

		return NULL;

	}



	transport_device_setup_cmd(se_cmd);

	return se_cmd;

}
@@ -143,17 +141,17 @@ static int tcm_loop_new_cmd_map(struct se_cmd *se_cmd) 
	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,

				struct tcm_loop_cmd, tl_se_cmd);

	struct scsi_cmnd *sc = tl_cmd->sc;

	void *mem_ptr, *mem_bidi_ptr = NULL;

	u32 sg_no_bidi = 0;

	struct scatterlist *sgl_bidi = NULL;

	u32 sgl_bidi_count = 0;

	int ret;

	/*

	 * Allocate the necessary tasks to complete the received CDB+data

	 */

	ret = transport_generic_allocate_tasks(se_cmd, tl_cmd->sc->cmnd);

	if (ret == -1) {

	ret = transport_generic_allocate_tasks(se_cmd, sc->cmnd);

	if (ret == -ENOMEM) {

		/* Out of Resources */

		return PYX_TRANSPORT_LU_COMM_FAILURE;

	} else if (ret == -2) {

	} else if (ret == -EINVAL) {

		/*

		 * Handle case for SAM_STAT_RESERVATION_CONFLICT

		 */
@@ -165,35 +163,21 @@ static int tcm_loop_new_cmd_map(struct se_cmd *se_cmd) 
		 */

		return PYX_TRANSPORT_USE_SENSE_REASON;

	}

	/*

	 * Setup the struct scatterlist memory from the received

	 * struct scsi_cmnd.

	 */

	if (scsi_sg_count(sc)) {

		se_cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM;

		mem_ptr = (void *)scsi_sglist(sc);



	/*

	 * For BIDI commands, pass in the extra READ buffer

	 * to transport_generic_map_mem_to_cmd() below..

	 */

		if (T_TASK(se_cmd)->t_tasks_bidi) {

	if (se_cmd->t_tasks_bidi) {

		struct scsi_data_buffer *sdb = scsi_in(sc);



			mem_bidi_ptr = (void *)sdb->table.sgl;

			sg_no_bidi = sdb->table.nents;

		sgl_bidi = sdb->table.sgl;

		sgl_bidi_count = sdb->table.nents;

	}

	} else {

		/*

		 * Used for DMA_NONE

		 */

		mem_ptr = NULL;

	}

	/*

	 * Map the SG memory into struct se_mem->page linked list using the same

	 * physical memory at sg->page_link.

	 */

	ret = transport_generic_map_mem_to_cmd(se_cmd, mem_ptr,

			scsi_sg_count(sc), mem_bidi_ptr, sg_no_bidi);



	/* Tell the core about our preallocated memory */

	ret = transport_generic_map_mem_to_cmd(se_cmd, scsi_sglist(sc),

			scsi_sg_count(sc), sgl_bidi, sgl_bidi_count);

	if (ret < 0)

		return PYX_TRANSPORT_LU_COMM_FAILURE;
@@ -216,13 +200,10 @@ static void tcm_loop_check_stop_free(struct se_cmd *se_cmd) 
	 * 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, 1, 0);

	transport_generic_free_cmd(se_cmd, 0, 0);

}



/*

 * Called from struct target_core_fabric_ops->release_cmd_to_pool()

 */

static void tcm_loop_deallocate_core_cmd(struct se_cmd *se_cmd)

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);
@@ -300,7 +281,7 @@ static int tcm_loop_queuecommand( 
	struct tcm_loop_hba *tl_hba;

	struct tcm_loop_tpg *tl_tpg;



	TL_CDB_DEBUG("tcm_loop_queuecommand() %d:%d:%d:%d got CDB: 0x%02x"

	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));
@@ -350,7 +331,7 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc) 
	 */

	tl_nexus = tl_hba->tl_nexus;

	if (!tl_nexus) {

		printk(KERN_ERR "Unable to perform device reset without"

		pr_err("Unable to perform device reset without"

				" active I_T Nexus\n");

		return FAILED;

	}
@@ -363,13 +344,13 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc) 


	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_KERNEL);

	if (!tl_cmd) {

		printk(KERN_ERR "Unable to allocate memory for tl_cmd\n");

		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) {

		printk(KERN_ERR "Unable to allocate memory for tl_tmr\n");

		pr_err("Unable to allocate memory for tl_tmr\n");

		goto release;

	}

	init_waitqueue_head(&tl_tmr->tl_tmr_wait);
@@ -384,14 +365,14 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc) 
	/*

	 * Allocate the LUN_RESET TMR

	 */

	se_cmd->se_tmr_req = core_tmr_alloc_req(se_cmd, (void *)tl_tmr,

	se_cmd->se_tmr_req = core_tmr_alloc_req(se_cmd, tl_tmr,

				TMR_LUN_RESET);

	if (IS_ERR(se_cmd->se_tmr_req))

		goto release;

	/*

	 * Locate the underlying TCM struct se_lun from sc->device->lun

	 */

	if (transport_get_lun_for_tmr(se_cmd, sc->device->lun) < 0)

	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()
@@ -407,7 +388,7 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc) 
		SUCCESS : FAILED;

release:

	if (se_cmd)

		transport_generic_free_cmd(se_cmd, 1, 1, 0);

		transport_generic_free_cmd(se_cmd, 1, 0);

	else

		kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);

	kfree(tl_tmr);
@@ -454,7 +435,7 @@ static int tcm_loop_driver_probe(struct device *dev) 
	sh = scsi_host_alloc(&tcm_loop_driver_template,

			sizeof(struct tcm_loop_hba));

	if (!sh) {

		printk(KERN_ERR "Unable to allocate struct scsi_host\n");

		pr_err("Unable to allocate struct scsi_host\n");

		return -ENODEV;

	}

	tl_hba->sh = sh;
@@ -473,7 +454,7 @@ static int tcm_loop_driver_probe(struct device *dev) 


	error = scsi_add_host(sh, &tl_hba->dev);

	if (error) {

		printk(KERN_ERR "%s: scsi_add_host failed\n", __func__);

		pr_err("%s: scsi_add_host failed\n", __func__);

		scsi_host_put(sh);

		return -ENODEV;

	}
@@ -514,7 +495,7 @@ static int tcm_loop_setup_hba_bus(struct tcm_loop_hba *tl_hba, int tcm_loop_host 


	ret = device_register(&tl_hba->dev);

	if (ret) {

		printk(KERN_ERR "device_register() failed for"

		pr_err("device_register() failed for"

				" tl_hba->dev: %d\n", ret);

		return -ENODEV;

	}
@@ -532,24 +513,24 @@ static int tcm_loop_alloc_core_bus(void) 


	tcm_loop_primary = root_device_register("tcm_loop_0");

	if (IS_ERR(tcm_loop_primary)) {

		printk(KERN_ERR "Unable to allocate tcm_loop_primary\n");

		pr_err("Unable to allocate tcm_loop_primary\n");

		return PTR_ERR(tcm_loop_primary);

	}



	ret = bus_register(&tcm_loop_lld_bus);

	if (ret) {

		printk(KERN_ERR "bus_register() failed for tcm_loop_lld_bus\n");

		pr_err("bus_register() failed for tcm_loop_lld_bus\n");

		goto dev_unreg;

	}



	ret = driver_register(&tcm_loop_driverfs);

	if (ret) {

		printk(KERN_ERR "driver_register() failed for"

		pr_err("driver_register() failed for"

				"tcm_loop_driverfs\n");

		goto bus_unreg;

	}



	printk(KERN_INFO "Initialized TCM Loop Core Bus\n");

	pr_debug("Initialized TCM Loop Core Bus\n");

	return ret;



bus_unreg:
@@ -565,7 +546,7 @@ static void tcm_loop_release_core_bus(void) 
	bus_unregister(&tcm_loop_lld_bus);

	root_device_unregister(tcm_loop_primary);



	printk(KERN_INFO "Releasing TCM Loop Core BUS\n");

	pr_debug("Releasing TCM Loop Core BUS\n");

}



static char *tcm_loop_get_fabric_name(void)
@@ -593,7 +574,7 @@ static u8 tcm_loop_get_fabric_proto_ident(struct se_portal_group *se_tpg) 
	case SCSI_PROTOCOL_ISCSI:

		return iscsi_get_fabric_proto_ident(se_tpg);

	default:

		printk(KERN_ERR "Unknown tl_proto_id: 0x%02x, using"

		pr_err("Unknown tl_proto_id: 0x%02x, using"

			" SAS emulation\n", tl_hba->tl_proto_id);

		break;

	}
@@ -649,7 +630,7 @@ static u32 tcm_loop_get_pr_transport_id( 
		return iscsi_get_pr_transport_id(se_tpg, se_nacl, pr_reg,

					format_code, buf);

	default:

		printk(KERN_ERR "Unknown tl_proto_id: 0x%02x, using"

		pr_err("Unknown tl_proto_id: 0x%02x, using"

			" SAS emulation\n", tl_hba->tl_proto_id);

		break;

	}
@@ -679,7 +660,7 @@ static u32 tcm_loop_get_pr_transport_id_len( 
		return iscsi_get_pr_transport_id_len(se_tpg, se_nacl, pr_reg,

					format_code);

	default:

		printk(KERN_ERR "Unknown tl_proto_id: 0x%02x, using"

		pr_err("Unknown tl_proto_id: 0x%02x, using"

			" SAS emulation\n", tl_hba->tl_proto_id);

		break;

	}
@@ -713,7 +694,7 @@ static char *tcm_loop_parse_pr_out_transport_id( 
		return iscsi_parse_pr_out_transport_id(se_tpg, buf, out_tid_len,

					port_nexus_ptr);

	default:

		printk(KERN_ERR "Unknown tl_proto_id: 0x%02x, using"

		pr_err("Unknown tl_proto_id: 0x%02x, using"

			" SAS emulation\n", tl_hba->tl_proto_id);

		break;

	}
@@ -762,7 +743,7 @@ static struct se_node_acl *tcm_loop_tpg_alloc_fabric_acl( 


	tl_nacl = kzalloc(sizeof(struct tcm_loop_nacl), GFP_KERNEL);

	if (!tl_nacl) {

		printk(KERN_ERR "Unable to allocate struct tcm_loop_nacl\n");

		pr_err("Unable to allocate struct tcm_loop_nacl\n");

		return NULL;

	}
@@ -784,16 +765,6 @@ static u32 tcm_loop_get_inst_index(struct se_portal_group *se_tpg) 
	return 1;

}



static void tcm_loop_new_cmd_failure(struct se_cmd *se_cmd)

{

	/*

	 * Since TCM_loop is already passing struct scatterlist data from

	 * struct scsi_cmnd, no more Linux/SCSI failure dependent state need

	 * to be handled here.

	 */

	return;

}



static int tcm_loop_is_state_remove(struct se_cmd *se_cmd)

{

	/*
@@ -882,7 +853,7 @@ static int tcm_loop_queue_data_in(struct se_cmd *se_cmd) 
				struct tcm_loop_cmd, tl_se_cmd);

	struct scsi_cmnd *sc = tl_cmd->sc;



	TL_CDB_DEBUG("tcm_loop_queue_data_in() called for scsi_cmnd: %p"

	pr_debug("tcm_loop_queue_data_in() called for scsi_cmnd: %p"

		     " cdb: 0x%02x\n", sc, sc->cmnd[0]);



	sc->result = SAM_STAT_GOOD;
@@ -897,14 +868,14 @@ static int tcm_loop_queue_status(struct se_cmd *se_cmd) 
				struct tcm_loop_cmd, tl_se_cmd);

	struct scsi_cmnd *sc = tl_cmd->sc;



	TL_CDB_DEBUG("tcm_loop_queue_status() called for scsi_cmnd: %p"

	pr_debug("tcm_loop_queue_status() called for scsi_cmnd: %p"

			" cdb: 0x%02x\n", sc, sc->cmnd[0]);



	if (se_cmd->sense_buffer &&

	   ((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||

	    (se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {



		memcpy((void *)sc->sense_buffer, (void *)se_cmd->sense_buffer,

		memcpy(sc->sense_buffer, se_cmd->sense_buffer,

				SCSI_SENSE_BUFFERSIZE);

		sc->result = SAM_STAT_CHECK_CONDITION;

		set_driver_byte(sc, DRIVER_SENSE);
@@ -972,7 +943,7 @@ static int tcm_loop_port_link( 
	 */

	scsi_add_device(tl_hba->sh, 0, tl_tpg->tl_tpgt, lun->unpacked_lun);



	printk(KERN_INFO "TCM_Loop_ConfigFS: Port Link Successful\n");

	pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n");

	return 0;

}
@@ -990,7 +961,7 @@ static void tcm_loop_port_unlink( 
	sd = scsi_device_lookup(tl_hba->sh, 0, tl_tpg->tl_tpgt,

				se_lun->unpacked_lun);

	if (!sd) {

		printk(KERN_ERR "Unable to locate struct scsi_device for %d:%d:"

		pr_err("Unable to locate struct scsi_device for %d:%d:"

			"%d\n", 0, tl_tpg->tl_tpgt, se_lun->unpacked_lun);

		return;

	}
@@ -1003,7 +974,7 @@ static void tcm_loop_port_unlink( 
	atomic_dec(&tl_tpg->tl_tpg_port_count);

	smp_mb__after_atomic_dec();



	printk(KERN_INFO "TCM_Loop_ConfigFS: Port Unlink Successful\n");

	pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");

}



/* End items for tcm_loop_port_cit */
@@ -1020,14 +991,14 @@ static int tcm_loop_make_nexus( 
	int ret = -ENOMEM;



	if (tl_tpg->tl_hba->tl_nexus) {

		printk(KERN_INFO "tl_tpg->tl_hba->tl_nexus already exists\n");

		pr_debug("tl_tpg->tl_hba->tl_nexus already exists\n");

		return -EEXIST;

	}

	se_tpg = &tl_tpg->tl_se_tpg;



	tl_nexus = kzalloc(sizeof(struct tcm_loop_nexus), GFP_KERNEL);

	if (!tl_nexus) {

		printk(KERN_ERR "Unable to allocate struct tcm_loop_nexus\n");

		pr_err("Unable to allocate struct tcm_loop_nexus\n");

		return -ENOMEM;

	}

	/*
@@ -1054,9 +1025,9 @@ static int tcm_loop_make_nexus( 
	 * transport_register_session()

	 */

	__transport_register_session(se_tpg, tl_nexus->se_sess->se_node_acl,

			tl_nexus->se_sess, (void *)tl_nexus);

			tl_nexus->se_sess, tl_nexus);

	tl_tpg->tl_hba->tl_nexus = tl_nexus;

	printk(KERN_INFO "TCM_Loop_ConfigFS: Established I_T Nexus to emulated"

	pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated"

		" %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba),

		name);

	return 0;
@@ -1082,13 +1053,13 @@ static int tcm_loop_drop_nexus( 
		return -ENODEV;



	if (atomic_read(&tpg->tl_tpg_port_count)) {

		printk(KERN_ERR "Unable to remove TCM_Loop I_T Nexus with"

		pr_err("Unable to remove TCM_Loop I_T Nexus with"

			" active TPG port count: %d\n",

			atomic_read(&tpg->tl_tpg_port_count));

		return -EPERM;

	}



	printk(KERN_INFO "TCM_Loop_ConfigFS: Removing I_T Nexus to emulated"

	pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated"

		" %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba),

		tl_nexus->se_sess->se_node_acl->initiatorname);

	/*
@@ -1144,7 +1115,7 @@ static ssize_t tcm_loop_tpg_store_nexus( 
	 * tcm_loop_make_nexus()

	 */

	if (strlen(page) >= TL_WWN_ADDR_LEN) {

		printk(KERN_ERR "Emulated NAA Sas Address: %s, exceeds"

		pr_err("Emulated NAA Sas Address: %s, exceeds"

				" max: %d\n", page, TL_WWN_ADDR_LEN);

		return -EINVAL;

	}
@@ -1153,7 +1124,7 @@ static ssize_t tcm_loop_tpg_store_nexus( 
	ptr = strstr(i_port, "naa.");

	if (ptr) {

		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_SAS) {

			printk(KERN_ERR "Passed SAS Initiator Port %s does not"

			pr_err("Passed SAS Initiator Port %s does not"

				" match target port protoid: %s\n", i_port,

				tcm_loop_dump_proto_id(tl_hba));

			return -EINVAL;
@@ -1164,7 +1135,7 @@ static ssize_t tcm_loop_tpg_store_nexus( 
	ptr = strstr(i_port, "fc.");

	if (ptr) {

		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_FCP) {

			printk(KERN_ERR "Passed FCP Initiator Port %s does not"

			pr_err("Passed FCP Initiator Port %s does not"

				" match target port protoid: %s\n", i_port,

				tcm_loop_dump_proto_id(tl_hba));

			return -EINVAL;
@@ -1175,7 +1146,7 @@ static ssize_t tcm_loop_tpg_store_nexus( 
	ptr = strstr(i_port, "iqn.");

	if (ptr) {

		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_ISCSI) {

			printk(KERN_ERR "Passed iSCSI Initiator Port %s does not"

			pr_err("Passed iSCSI Initiator Port %s does not"

				" match target port protoid: %s\n", i_port,

				tcm_loop_dump_proto_id(tl_hba));

			return -EINVAL;
@@ -1183,7 +1154,7 @@ static ssize_t tcm_loop_tpg_store_nexus( 
		port_ptr = &i_port[0];

		goto check_newline;

	}

	printk(KERN_ERR "Unable to locate prefix for emulated Initiator Port:"

	pr_err("Unable to locate prefix for emulated Initiator Port:"

			" %s\n", i_port);

	return -EINVAL;

	/*
@@ -1223,15 +1194,15 @@ struct se_portal_group *tcm_loop_make_naa_tpg( 


	tpgt_str = strstr(name, "tpgt_");

	if (!tpgt_str) {

		printk(KERN_ERR "Unable to locate \"tpgt_#\" directory"

		pr_err("Unable to locate \"tpgt_#\" directory"

				" group\n");

		return ERR_PTR(-EINVAL);

	}

	tpgt_str += 5; /* Skip ahead of "tpgt_" */

	tpgt = (unsigned short int) simple_strtoul(tpgt_str, &end_ptr, 0);



	if (tpgt > TL_TPGS_PER_HBA) {

		printk(KERN_ERR "Passed tpgt: %hu exceeds TL_TPGS_PER_HBA:"

	if (tpgt >= TL_TPGS_PER_HBA) {

		pr_err("Passed tpgt: %hu exceeds TL_TPGS_PER_HBA:"

				" %u\n", tpgt, TL_TPGS_PER_HBA);

		return ERR_PTR(-EINVAL);

	}
@@ -1242,12 +1213,12 @@ struct se_portal_group *tcm_loop_make_naa_tpg( 
	 * Register the tl_tpg as a emulated SAS TCM Target Endpoint

	 */

	ret = core_tpg_register(&tcm_loop_fabric_configfs->tf_ops,

			wwn, &tl_tpg->tl_se_tpg, (void *)tl_tpg,

			wwn, &tl_tpg->tl_se_tpg, tl_tpg,

			TRANSPORT_TPG_TYPE_NORMAL);

	if (ret < 0)

		return ERR_PTR(-ENOMEM);



	printk(KERN_INFO "TCM_Loop_ConfigFS: Allocated Emulated %s"

	pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s"

		" Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba),

		config_item_name(&wwn->wwn_group.cg_item), tpgt);
@@ -1274,7 +1245,7 @@ void tcm_loop_drop_naa_tpg( 
	 */

	core_tpg_deregister(se_tpg);



	printk(KERN_INFO "TCM_Loop_ConfigFS: Deallocated Emulated %s"

	pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s"

		" Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba),

		config_item_name(&wwn->wwn_group.cg_item), tpgt);

}
@@ -1295,7 +1266,7 @@ struct se_wwn *tcm_loop_make_scsi_hba( 


	tl_hba = kzalloc(sizeof(struct tcm_loop_hba), GFP_KERNEL);

	if (!tl_hba) {

		printk(KERN_ERR "Unable to allocate struct tcm_loop_hba\n");

		pr_err("Unable to allocate struct tcm_loop_hba\n");

		return ERR_PTR(-ENOMEM);

	}

	/*
@@ -1314,22 +1285,21 @@ struct se_wwn *tcm_loop_make_scsi_hba( 
		goto check_len;

	}

	ptr = strstr(name, "iqn.");

	if (ptr) {

		tl_hba->tl_proto_id = SCSI_PROTOCOL_ISCSI;

		goto check_len;

	if (!ptr) {

		pr_err("Unable to locate prefix for emulated Target "

				"Port: %s\n", name);

		ret = -EINVAL;

		goto out;

	}



	printk(KERN_ERR "Unable to locate prefix for emulated Target Port:"

			" %s\n", name);

	return ERR_PTR(-EINVAL);

	tl_hba->tl_proto_id = SCSI_PROTOCOL_ISCSI;



check_len:

	if (strlen(name) >= TL_WWN_ADDR_LEN) {

		printk(KERN_ERR "Emulated NAA %s Address: %s, exceeds"

		pr_err("Emulated NAA %s Address: %s, exceeds"

			" max: %d\n", name, tcm_loop_dump_proto_id(tl_hba),

			TL_WWN_ADDR_LEN);

		kfree(tl_hba);

		return ERR_PTR(-EINVAL);

		ret = -EINVAL;

		goto out;

	}

	snprintf(&tl_hba->tl_wwn_address[0], TL_WWN_ADDR_LEN, "%s", &name[off]);
@@ -1344,7 +1314,7 @@ struct se_wwn *tcm_loop_make_scsi_hba( 


	sh = tl_hba->sh;

	tcm_loop_hba_no_cnt++;

	printk(KERN_INFO "TCM_Loop_ConfigFS: Allocated emulated Target"

	pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target"

		" %s Address: %s at Linux/SCSI Host ID: %d\n",

		tcm_loop_dump_proto_id(tl_hba), name, sh->host_no);
@@ -1367,7 +1337,7 @@ void tcm_loop_drop_scsi_hba( 
	 */

	device_unregister(&tl_hba->dev);



	printk(KERN_INFO "TCM_Loop_ConfigFS: Deallocated emulated Target"

	pr_debug("TCM_Loop_ConfigFS: Deallocated emulated Target"

		" SAS Address: %s at Linux/SCSI Host ID: %d\n",

		config_item_name(&wwn->wwn_group.cg_item), host_no);

}
@@ -1402,9 +1372,9 @@ static int tcm_loop_register_configfs(void) 
	 * Register the top level struct config_item_type with TCM core

	 */

	fabric = target_fabric_configfs_init(THIS_MODULE, "loopback");

	if (!fabric) {

		printk(KERN_ERR "tcm_loop_register_configfs() failed!\n");

		return -1;

	if (IS_ERR(fabric)) {

		pr_err("tcm_loop_register_configfs() failed!\n");

		return PTR_ERR(fabric);

	}

	/*

	 * Setup the fabric API of function pointers used by target_core_mod
@@ -1435,20 +1405,12 @@ static int tcm_loop_register_configfs(void) 
	fabric->tf_ops.tpg_release_fabric_acl =

					&tcm_loop_tpg_release_fabric_acl;

	fabric->tf_ops.tpg_get_inst_index = &tcm_loop_get_inst_index;

	/*

	 * Since tcm_loop is mapping physical memory from Linux/SCSI

	 * struct scatterlist arrays for each struct scsi_cmnd I/O,

	 * we do not need TCM to allocate a iovec array for

	 * virtual memory address mappings

	 */

	fabric->tf_ops.alloc_cmd_iovecs = NULL;

	/*

	 * Used for setting up remaining TCM resources in process context

	 */

	fabric->tf_ops.new_cmd_map = &tcm_loop_new_cmd_map;

	fabric->tf_ops.check_stop_free = &tcm_loop_check_stop_free;

	fabric->tf_ops.release_cmd_to_pool = &tcm_loop_deallocate_core_cmd;

	fabric->tf_ops.release_cmd_direct = &tcm_loop_deallocate_core_cmd;

	fabric->tf_ops.release_cmd = &tcm_loop_release_cmd;

	fabric->tf_ops.shutdown_session = &tcm_loop_shutdown_session;

	fabric->tf_ops.close_session = &tcm_loop_close_session;

	fabric->tf_ops.stop_session = &tcm_loop_stop_session;
@@ -1465,7 +1427,6 @@ static int tcm_loop_register_configfs(void) 
					&tcm_loop_set_default_node_attributes;

	fabric->tf_ops.get_task_tag = &tcm_loop_get_task_tag;

	fabric->tf_ops.get_cmd_state = &tcm_loop_get_cmd_state;

	fabric->tf_ops.new_cmd_failure = &tcm_loop_new_cmd_failure;

	fabric->tf_ops.queue_data_in = &tcm_loop_queue_data_in;

	fabric->tf_ops.queue_status = &tcm_loop_queue_status;

	fabric->tf_ops.queue_tm_rsp = &tcm_loop_queue_tm_rsp;
@@ -1503,7 +1464,7 @@ static int tcm_loop_register_configfs(void) 
	 */

	ret = target_fabric_configfs_register(fabric);

	if (ret < 0) {

		printk(KERN_ERR "target_fabric_configfs_register() for"

		pr_err("target_fabric_configfs_register() for"

				" TCM_Loop failed!\n");

		target_fabric_configfs_free(fabric);

		return -1;
@@ -1512,7 +1473,7 @@ static int tcm_loop_register_configfs(void) 
	 * Setup our local pointer to *fabric.

	 */

	tcm_loop_fabric_configfs = fabric;

	printk(KERN_INFO "TCM_LOOP[0] - Set fabric ->"

	pr_debug("TCM_LOOP[0] - Set fabric ->"

			" tcm_loop_fabric_configfs\n");

	return 0;

}
@@ -1524,7 +1485,7 @@ static void tcm_loop_deregister_configfs(void) 


	target_fabric_configfs_deregister(tcm_loop_fabric_configfs);

	tcm_loop_fabric_configfs = NULL;

	printk(KERN_INFO "TCM_LOOP[0] - Cleared"

	pr_debug("TCM_LOOP[0] - Cleared"

				" tcm_loop_fabric_configfs\n");

}
@@ -1537,7 +1498,7 @@ static int __init tcm_loop_fabric_init(void) 
				__alignof__(struct tcm_loop_cmd),

				0, NULL);

	if (!tcm_loop_cmd_cache) {

		printk(KERN_ERR "kmem_cache_create() for"

		pr_debug("kmem_cache_create() for"

			" tcm_loop_cmd_cache failed\n");

		return -ENOMEM;

	}

drivers/target/loopback/tcm_loop.h

+0 −6
Original line number Diff line number Diff line
@@ -16,12 +16,6 @@ 
 */

#define TL_SCSI_MAX_CMD_LEN		32



#ifdef CONFIG_LOOPBACK_TARGET_CDB_DEBUG

# define TL_CDB_DEBUG(x...)		printk(KERN_INFO x)

#else

# define TL_CDB_DEBUG(x...)

#endif



struct tcm_loop_cmd {

	/* State of Linux/SCSI CDB+Data descriptor */

	u32 sc_cmd_state;