tcm_loop.c

   1/*******************************************************************************
   2 *
   3 * This file contains the Linux/SCSI LLD virtual SCSI initiator driver
   4 * for emulated SAS initiator ports
   5 *
   6 * © Copyright 2011-2013 Datera, Inc.
   7 *
   8 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
   9 *
  10 * Author: Nicholas A. Bellinger <nab@risingtidesystems.com>
  11 *
  12 * This program is free software; you can redistribute it and/or modify
  13 * it under the terms of the GNU General Public License as published by
  14 * the Free Software Foundation; either version 2 of the License, or
  15 * (at your option) any later version.
  16 *
  17 * This program is distributed in the hope that it will be useful,
  18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 * GNU General Public License for more details.
  21 ****************************************************************************/
  22
  23#include <linux/module.h>
  24#include <linux/moduleparam.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/types.h>
  28#include <linux/configfs.h>
  29#include <linux/blk-mq.h>
  30#include <scsi/scsi.h>
  31#include <scsi/scsi_tcq.h>
  32#include <scsi/scsi_host.h>
  33#include <scsi/scsi_device.h>
  34#include <scsi/scsi_cmnd.h>
  35
  36#include <target/target_core_base.h>
  37#include <target/target_core_fabric.h>
  38
  39#include "tcm_loop.h"
  40
  41#define to_tcm_loop_hba(hba)	container_of(hba, struct tcm_loop_hba, dev)
  42
  43static struct kmem_cache *tcm_loop_cmd_cache;
  44
  45static int tcm_loop_hba_no_cnt;
  46
  47static int tcm_loop_queue_status(struct se_cmd *se_cmd);
  48
  49static unsigned int tcm_loop_nr_hw_queues = 1;
  50module_param_named(nr_hw_queues, tcm_loop_nr_hw_queues, uint, 0644);
  51
  52static unsigned int tcm_loop_can_queue = 1024;
  53module_param_named(can_queue, tcm_loop_can_queue, uint, 0644);
  54
  55static unsigned int tcm_loop_cmd_per_lun = 1024;
  56module_param_named(cmd_per_lun, tcm_loop_cmd_per_lun, uint, 0644);
  57
  58/*
  59 * Called from struct target_core_fabric_ops->check_stop_free()
  60 */
  61static int tcm_loop_check_stop_free(struct se_cmd *se_cmd)
  62{
  63	return transport_generic_free_cmd(se_cmd, 0);
  64}
  65
  66static void tcm_loop_release_cmd(struct se_cmd *se_cmd)
  67{
  68	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
  69				struct tcm_loop_cmd, tl_se_cmd);
  70	struct scsi_cmnd *sc = tl_cmd->sc;
  71
  72	if (se_cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
  73		kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);
  74	else
  75		scsi_done(sc);
  76}
  77
  78static int tcm_loop_show_info(struct seq_file *m, struct Scsi_Host *host)
  79{
  80	seq_puts(m, "tcm_loop_proc_info()\n");
  81	return 0;
  82}
  83
  84static int tcm_loop_driver_probe(struct device *);
  85static void tcm_loop_driver_remove(struct device *);
  86
  87static const struct bus_type tcm_loop_lld_bus = {
  88	.name			= "tcm_loop_bus",
  89	.probe			= tcm_loop_driver_probe,
  90	.remove			= tcm_loop_driver_remove,
  91};
  92
  93static struct device_driver tcm_loop_driverfs = {
  94	.name			= "tcm_loop",
  95	.bus			= &tcm_loop_lld_bus,
  96};
  97/*
  98 * Used with root_device_register() in tcm_loop_alloc_core_bus() below
  99 */
 100static struct device *tcm_loop_primary;
 101
 102static void tcm_loop_target_queue_cmd(struct tcm_loop_cmd *tl_cmd)
 103{
 104	struct se_cmd *se_cmd = &tl_cmd->tl_se_cmd;
 105	struct scsi_cmnd *sc = tl_cmd->sc;
 106	struct tcm_loop_nexus *tl_nexus;
 107	struct tcm_loop_hba *tl_hba;
 108	struct tcm_loop_tpg *tl_tpg;
 109	struct scatterlist *sgl_bidi = NULL;
 110	u32 sgl_bidi_count = 0, transfer_length;
 111
 112	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);
 113	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];
 114
 115	/*
 116	 * Ensure that this tl_tpg reference from the incoming sc->device->id
 117	 * has already been configured via tcm_loop_make_naa_tpg().
 118	 */
 119	if (!tl_tpg->tl_hba) {
 120		set_host_byte(sc, DID_NO_CONNECT);
 121		goto out_done;
 122	}
 123	if (tl_tpg->tl_transport_status == TCM_TRANSPORT_OFFLINE) {
 124		set_host_byte(sc, DID_TRANSPORT_DISRUPTED);
 125		goto out_done;
 126	}
 127	tl_nexus = tl_tpg->tl_nexus;
 128	if (!tl_nexus) {
 129		scmd_printk(KERN_ERR, sc,
 130			    "TCM_Loop I_T Nexus does not exist\n");
 131		set_host_byte(sc, DID_ERROR);
 132		goto out_done;
 133	}
 134
 135	transfer_length = scsi_transfer_length(sc);
 136	if (!scsi_prot_sg_count(sc) &&
 137	    scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) {
 138		se_cmd->prot_pto = true;
 139		/*
 140		 * loopback transport doesn't support
 141		 * WRITE_GENERATE, READ_STRIP protection
 142		 * information operations, go ahead unprotected.
 143		 */
 144		transfer_length = scsi_bufflen(sc);
 145	}
 146
 147	se_cmd->tag = tl_cmd->sc_cmd_tag;
 148	target_init_cmd(se_cmd, tl_nexus->se_sess, &tl_cmd->tl_sense_buf[0],
 149			tl_cmd->sc->device->lun, transfer_length,
 150			TCM_SIMPLE_TAG, sc->sc_data_direction, 0);
 151
 152	if (target_submit_prep(se_cmd, sc->cmnd, scsi_sglist(sc),
 153			       scsi_sg_count(sc), sgl_bidi, sgl_bidi_count,
 154			       scsi_prot_sglist(sc), scsi_prot_sg_count(sc),
 155			       GFP_ATOMIC))
 156		return;
 157
 158	target_submit(se_cmd);
 159	return;
 160
 161out_done:
 162	scsi_done(sc);
 163}
 164
 165/*
 166 * ->queuecommand can be and usually is called from interrupt context, so
 167 * defer the actual submission to a workqueue.
 168 */
 169static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
 170{
 171	struct tcm_loop_cmd *tl_cmd = scsi_cmd_priv(sc);
 172
 173	pr_debug("%s() %d:%d:%d:%llu got CDB: 0x%02x scsi_buf_len: %u\n",
 174		 __func__, sc->device->host->host_no, sc->device->id,
 175		 sc->device->channel, sc->device->lun, sc->cmnd[0],
 176		 scsi_bufflen(sc));
 177
 178	memset(tl_cmd, 0, sizeof(*tl_cmd));
 179	tl_cmd->sc = sc;
 180	tl_cmd->sc_cmd_tag = blk_mq_unique_tag(scsi_cmd_to_rq(sc));
 181
 182	tcm_loop_target_queue_cmd(tl_cmd);
 183	return 0;
 184}
 185
 186/*
 187 * Called from SCSI EH process context to issue a LUN_RESET TMR
 188 * to struct scsi_device
 189 */
 190static int tcm_loop_issue_tmr(struct tcm_loop_tpg *tl_tpg,
 191			      u64 lun, int task, enum tcm_tmreq_table tmr)
 192{
 193	struct se_cmd *se_cmd;
 194	struct se_session *se_sess;
 195	struct tcm_loop_nexus *tl_nexus;
 196	struct tcm_loop_cmd *tl_cmd;
 197	int ret = TMR_FUNCTION_FAILED, rc;
 198
 199	/*
 200	 * Locate the tl_nexus and se_sess pointers
 201	 */
 202	tl_nexus = tl_tpg->tl_nexus;
 203	if (!tl_nexus) {
 204		pr_err("Unable to perform device reset without active I_T Nexus\n");
 205		return ret;
 206	}
 207
 208	tl_cmd = kmem_cache_zalloc(tcm_loop_cmd_cache, GFP_KERNEL);
 209	if (!tl_cmd)
 210		return ret;
 211
 212	init_completion(&tl_cmd->tmr_done);
 213
 214	se_cmd = &tl_cmd->tl_se_cmd;
 215	se_sess = tl_tpg->tl_nexus->se_sess;
 216
 217	rc = target_submit_tmr(se_cmd, se_sess, tl_cmd->tl_sense_buf, lun,
 218			       NULL, tmr, GFP_KERNEL, task,
 219			       TARGET_SCF_ACK_KREF);
 220	if (rc < 0)
 221		goto release;
 222	wait_for_completion(&tl_cmd->tmr_done);
 223	ret = se_cmd->se_tmr_req->response;
 224	target_put_sess_cmd(se_cmd);
 225
 226out:
 227	return ret;
 228
 229release:
 230	kmem_cache_free(tcm_loop_cmd_cache, tl_cmd);
 231	goto out;
 232}
 233
 234static int tcm_loop_abort_task(struct scsi_cmnd *sc)
 235{
 236	struct tcm_loop_hba *tl_hba;
 237	struct tcm_loop_tpg *tl_tpg;
 238	int ret;
 239
 240	/*
 241	 * Locate the tcm_loop_hba_t pointer
 242	 */
 243	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);
 244	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];
 245	ret = tcm_loop_issue_tmr(tl_tpg, sc->device->lun,
 246				 blk_mq_unique_tag(scsi_cmd_to_rq(sc)),
 247				 TMR_ABORT_TASK);
 248	return (ret == TMR_FUNCTION_COMPLETE) ? SUCCESS : FAILED;
 249}
 250
 251/*
 252 * Called from SCSI EH process context to issue a LUN_RESET TMR
 253 * to struct scsi_device
 254 */
 255static int tcm_loop_device_reset(struct scsi_cmnd *sc)
 256{
 257	struct tcm_loop_hba *tl_hba;
 258	struct tcm_loop_tpg *tl_tpg;
 259	int ret;
 260
 261	/*
 262	 * Locate the tcm_loop_hba_t pointer
 263	 */
 264	tl_hba = *(struct tcm_loop_hba **)shost_priv(sc->device->host);
 265	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];
 266
 267	ret = tcm_loop_issue_tmr(tl_tpg, sc->device->lun,
 268				 0, TMR_LUN_RESET);
 269	return (ret == TMR_FUNCTION_COMPLETE) ? SUCCESS : FAILED;
 270}
 271
 272static bool tcm_loop_flush_work_iter(struct request *rq, void *data)
 273{
 274	struct scsi_cmnd *sc = blk_mq_rq_to_pdu(rq);
 275	struct tcm_loop_cmd *tl_cmd = scsi_cmd_priv(sc);
 276	struct se_cmd *se_cmd = &tl_cmd->tl_se_cmd;
 277
 278	flush_work(&se_cmd->work);
 279	return true;
 280}
 281
 282static int tcm_loop_target_reset(struct scsi_cmnd *sc)
 283{
 284	struct tcm_loop_hba *tl_hba;
 285	struct tcm_loop_tpg *tl_tpg;
 286	struct Scsi_Host *sh = sc->device->host;
 287	int ret;
 288
 289	/*
 290	 * Locate the tcm_loop_hba_t pointer
 291	 */
 292	tl_hba = *(struct tcm_loop_hba **)shost_priv(sh);
 293	if (!tl_hba) {
 294		pr_err("Unable to perform device reset without active I_T Nexus\n");
 295		return FAILED;
 296	}
 297	/*
 298	 * Locate the tl_tpg pointer from TargetID in sc->device->id
 299	 */
 300	tl_tpg = &tl_hba->tl_hba_tpgs[sc->device->id];
 301	if (!tl_tpg)
 302		return FAILED;
 303
 304	/*
 305	 * Issue a LUN_RESET to drain all commands that the target core
 306	 * knows about.  This handles commands not yet marked CMD_T_COMPLETE.
 307	 */
 308	ret = tcm_loop_issue_tmr(tl_tpg, sc->device->lun, 0, TMR_LUN_RESET);
 309	if (ret != TMR_FUNCTION_COMPLETE)
 310		return FAILED;
 311
 312	/*
 313	 * Flush any deferred target core completion work that may still be
 314	 * queued.  Commands that already had CMD_T_COMPLETE set before the TMR
 315	 * are skipped by the TMR drain, but their async completion work
 316	 * (transport_lun_remove_cmd → percpu_ref_put, release_cmd → scsi_done)
 317	 * may still be pending in target_completion_wq.
 318	 *
 319	 * The SCSI EH will reuse in-flight scsi_cmnd structures for recovery
 320	 * commands (e.g. TUR) immediately after this handler returns SUCCESS —
 321	 * if deferred work is still pending, the memset in queuecommand would
 322	 * zero the se_cmd while the work accesses it, leaking the LUN
 323	 * percpu_ref and hanging configfs unlink forever.
 324	 *
 325	 * Use blk_mq_tagset_busy_iter() to find all started requests and
 326	 * flush_work() on each — the same pattern used by mpi3mr, scsi_debug,
 327	 * and other SCSI drivers to drain outstanding commands during reset.
 328	 */
 329	blk_mq_tagset_busy_iter(&sh->tag_set, tcm_loop_flush_work_iter, NULL);
 330
 331	tl_tpg->tl_transport_status = TCM_TRANSPORT_ONLINE;
 332	return SUCCESS;
 333}
 334
 335static const struct scsi_host_template tcm_loop_driver_template = {
 336	.show_info		= tcm_loop_show_info,
 337	.proc_name		= "tcm_loopback",
 338	.name			= "TCM_Loopback",
 339	.queuecommand		= tcm_loop_queuecommand,
 340	.change_queue_depth	= scsi_change_queue_depth,
 341	.eh_abort_handler = tcm_loop_abort_task,
 342	.eh_device_reset_handler = tcm_loop_device_reset,
 343	.eh_target_reset_handler = tcm_loop_target_reset,
 344	.this_id		= -1,
 345	.sg_tablesize		= 256,
 346	.max_sectors		= 0xFFFF,
 347	.dma_boundary		= PAGE_SIZE - 1,
 348	.module			= THIS_MODULE,
 349	.track_queue_depth	= 1,
 350	.cmd_size		= sizeof(struct tcm_loop_cmd),
 351};
 352
 353static int tcm_loop_driver_probe(struct device *dev)
 354{
 355	struct tcm_loop_hba *tl_hba;
 356	struct Scsi_Host *sh;
 357	int error, host_prot;
 358
 359	tl_hba = to_tcm_loop_hba(dev);
 360
 361	sh = scsi_host_alloc(&tcm_loop_driver_template,
 362			sizeof(struct tcm_loop_hba));
 363	if (!sh) {
 364		pr_err("Unable to allocate struct scsi_host\n");
 365		return -ENODEV;
 366	}
 367	tl_hba->sh = sh;
 368
 369	/*
 370	 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata
 371	 */
 372	*((struct tcm_loop_hba **)sh->hostdata) = tl_hba;
 373	/*
 374	 * Setup single ID, Channel and LUN for now..
 375	 */
 376	sh->max_id = 2;
 377	sh->max_lun = 0;
 378	sh->max_channel = 0;
 379	sh->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE;
 380	sh->nr_hw_queues = tcm_loop_nr_hw_queues;
 381	sh->can_queue = tcm_loop_can_queue;
 382	sh->cmd_per_lun = tcm_loop_cmd_per_lun;
 383
 384	host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
 385		    SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |
 386		    SHOST_DIX_TYPE2_PROTECTION | SHOST_DIX_TYPE3_PROTECTION;
 387
 388	scsi_host_set_prot(sh, host_prot);
 389	scsi_host_set_guard(sh, SHOST_DIX_GUARD_CRC);
 390
 391	error = scsi_add_host(sh, &tl_hba->dev);
 392	if (error) {
 393		pr_err("%s: scsi_add_host failed\n", __func__);
 394		scsi_host_put(sh);
 395		return -ENODEV;
 396	}
 397	return 0;
 398}
 399
 400static void tcm_loop_driver_remove(struct device *dev)
 401{
 402	struct tcm_loop_hba *tl_hba;
 403	struct Scsi_Host *sh;
 404
 405	tl_hba = to_tcm_loop_hba(dev);
 406	sh = tl_hba->sh;
 407
 408	scsi_remove_host(sh);
 409	scsi_host_put(sh);
 410}
 411
 412static void tcm_loop_release_adapter(struct device *dev)
 413{
 414	struct tcm_loop_hba *tl_hba = to_tcm_loop_hba(dev);
 415
 416	kfree(tl_hba);
 417}
 418
 419/*
 420 * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c
 421 */
 422static int tcm_loop_setup_hba_bus(struct tcm_loop_hba *tl_hba, int tcm_loop_host_id)
 423{
 424	int ret;
 425
 426	tl_hba->dev.bus = &tcm_loop_lld_bus;
 427	tl_hba->dev.parent = tcm_loop_primary;
 428	tl_hba->dev.release = &tcm_loop_release_adapter;
 429	dev_set_name(&tl_hba->dev, "tcm_loop_adapter_%d", tcm_loop_host_id);
 430
 431	ret = device_register(&tl_hba->dev);
 432	if (ret) {
 433		pr_err("device_register() failed for tl_hba->dev: %d\n", ret);
 434		put_device(&tl_hba->dev);
 435		return -ENODEV;
 436	}
 437
 438	return 0;
 439}
 440
 441/*
 442 * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated
 443 * tcm_loop SCSI bus.
 444 */
 445static int tcm_loop_alloc_core_bus(void)
 446{
 447	int ret;
 448
 449	tcm_loop_primary = root_device_register("tcm_loop_0");
 450	if (IS_ERR(tcm_loop_primary)) {
 451		pr_err("Unable to allocate tcm_loop_primary\n");
 452		return PTR_ERR(tcm_loop_primary);
 453	}
 454
 455	ret = bus_register(&tcm_loop_lld_bus);
 456	if (ret) {
 457		pr_err("bus_register() failed for tcm_loop_lld_bus\n");
 458		goto dev_unreg;
 459	}
 460
 461	ret = driver_register(&tcm_loop_driverfs);
 462	if (ret) {
 463		pr_err("driver_register() failed for tcm_loop_driverfs\n");
 464		goto bus_unreg;
 465	}
 466
 467	pr_debug("Initialized TCM Loop Core Bus\n");
 468	return ret;
 469
 470bus_unreg:
 471	bus_unregister(&tcm_loop_lld_bus);
 472dev_unreg:
 473	root_device_unregister(tcm_loop_primary);
 474	return ret;
 475}
 476
 477static void tcm_loop_release_core_bus(void)
 478{
 479	driver_unregister(&tcm_loop_driverfs);
 480	bus_unregister(&tcm_loop_lld_bus);
 481	root_device_unregister(tcm_loop_primary);
 482
 483	pr_debug("Releasing TCM Loop Core BUS\n");
 484}
 485
 486static inline struct tcm_loop_tpg *tl_tpg(struct se_portal_group *se_tpg)
 487{
 488	return container_of(se_tpg, struct tcm_loop_tpg, tl_se_tpg);
 489}
 490
 491static char *tcm_loop_get_endpoint_wwn(struct se_portal_group *se_tpg)
 492{
 493	/*
 494	 * Return the passed NAA identifier for the Target Port
 495	 */
 496	return &tl_tpg(se_tpg)->tl_hba->tl_wwn_address[0];
 497}
 498
 499static u16 tcm_loop_get_tag(struct se_portal_group *se_tpg)
 500{
 501	/*
 502	 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83
 503	 * to represent the SCSI Target Port.
 504	 */
 505	return tl_tpg(se_tpg)->tl_tpgt;
 506}
 507
 508/*
 509 * Returning (1) here allows for target_core_mod struct se_node_acl to be generated
 510 * based upon the incoming fabric dependent SCSI Initiator Port
 511 */
 512static int tcm_loop_check_demo_mode(struct se_portal_group *se_tpg)
 513{
 514	return 1;
 515}
 516
 517static int tcm_loop_check_prot_fabric_only(struct se_portal_group *se_tpg)
 518{
 519	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, struct tcm_loop_tpg,
 520						   tl_se_tpg);
 521	return tl_tpg->tl_fabric_prot_type;
 522}
 523
 524static u32 tcm_loop_sess_get_index(struct se_session *se_sess)
 525{
 526	return 1;
 527}
 528
 529static int tcm_loop_get_cmd_state(struct se_cmd *se_cmd)
 530{
 531	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
 532			struct tcm_loop_cmd, tl_se_cmd);
 533
 534	return tl_cmd->sc_cmd_state;
 535}
 536
 537static int tcm_loop_write_pending(struct se_cmd *se_cmd)
 538{
 539	/*
 540	 * Since Linux/SCSI has already sent down a struct scsi_cmnd
 541	 * sc->sc_data_direction of DMA_TO_DEVICE with struct scatterlist array
 542	 * memory, and memory has already been mapped to struct se_cmd->t_mem_list
 543	 * format with transport_generic_map_mem_to_cmd().
 544	 *
 545	 * We now tell TCM to add this WRITE CDB directly into the TCM storage
 546	 * object execution queue.
 547	 */
 548	target_execute_cmd(se_cmd);
 549	return 0;
 550}
 551
 552static int tcm_loop_queue_data_or_status(const char *func,
 553		struct se_cmd *se_cmd, u8 scsi_status)
 554{
 555	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
 556				struct tcm_loop_cmd, tl_se_cmd);
 557	struct scsi_cmnd *sc = tl_cmd->sc;
 558
 559	pr_debug("%s() called for scsi_cmnd: %p cdb: 0x%02x\n",
 560		 func, sc, sc->cmnd[0]);
 561
 562	if (se_cmd->sense_buffer &&
 563	   ((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||
 564	    (se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {
 565
 566		memcpy(sc->sense_buffer, se_cmd->sense_buffer,
 567				SCSI_SENSE_BUFFERSIZE);
 568		sc->result = SAM_STAT_CHECK_CONDITION;
 569	} else
 570		sc->result = scsi_status;
 571
 572	set_host_byte(sc, DID_OK);
 573	if ((se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) ||
 574	    (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT))
 575		scsi_set_resid(sc, se_cmd->residual_count);
 576	return 0;
 577}
 578
 579static int tcm_loop_queue_data_in(struct se_cmd *se_cmd)
 580{
 581	return tcm_loop_queue_data_or_status(__func__, se_cmd, SAM_STAT_GOOD);
 582}
 583
 584static int tcm_loop_queue_status(struct se_cmd *se_cmd)
 585{
 586	return tcm_loop_queue_data_or_status(__func__,
 587					     se_cmd, se_cmd->scsi_status);
 588}
 589
 590static void tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd)
 591{
 592	struct tcm_loop_cmd *tl_cmd = container_of(se_cmd,
 593				struct tcm_loop_cmd, tl_se_cmd);
 594
 595	/* Wake up tcm_loop_issue_tmr(). */
 596	complete(&tl_cmd->tmr_done);
 597}
 598
 599static void tcm_loop_aborted_task(struct se_cmd *se_cmd)
 600{
 601	return;
 602}
 603
 604static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba)
 605{
 606	switch (tl_hba->tl_proto_id) {
 607	case SCSI_PROTOCOL_SAS:
 608		return "SAS";
 609	case SCSI_PROTOCOL_FCP:
 610		return "FCP";
 611	case SCSI_PROTOCOL_ISCSI:
 612		return "iSCSI";
 613	default:
 614		break;
 615	}
 616
 617	return "Unknown";
 618}
 619
 620/* Start items for tcm_loop_port_cit */
 621
 622static int tcm_loop_port_link(
 623	struct se_portal_group *se_tpg,
 624	struct se_lun *lun)
 625{
 626	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 627				struct tcm_loop_tpg, tl_se_tpg);
 628	struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
 629
 630	atomic_inc_mb(&tl_tpg->tl_tpg_port_count);
 631	/*
 632	 * Add Linux/SCSI struct scsi_device by HCTL
 633	 */
 634	scsi_add_device(tl_hba->sh, 0, tl_tpg->tl_tpgt, lun->unpacked_lun);
 635
 636	pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n");
 637	return 0;
 638}
 639
 640static void tcm_loop_port_unlink(
 641	struct se_portal_group *se_tpg,
 642	struct se_lun *se_lun)
 643{
 644	struct scsi_device *sd;
 645	struct tcm_loop_hba *tl_hba;
 646	struct tcm_loop_tpg *tl_tpg;
 647
 648	tl_tpg = container_of(se_tpg, struct tcm_loop_tpg, tl_se_tpg);
 649	tl_hba = tl_tpg->tl_hba;
 650
 651	sd = scsi_device_lookup(tl_hba->sh, 0, tl_tpg->tl_tpgt,
 652				se_lun->unpacked_lun);
 653	if (!sd) {
 654		pr_err("Unable to locate struct scsi_device for %d:%d:%llu\n",
 655		       0, tl_tpg->tl_tpgt, se_lun->unpacked_lun);
 656		return;
 657	}
 658	/*
 659	 * Remove Linux/SCSI struct scsi_device by HCTL
 660	 */
 661	scsi_remove_device(sd);
 662	scsi_device_put(sd);
 663
 664	atomic_dec_mb(&tl_tpg->tl_tpg_port_count);
 665
 666	pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");
 667}
 668
 669/* End items for tcm_loop_port_cit */
 670
 671static ssize_t tcm_loop_tpg_attrib_fabric_prot_type_show(
 672		struct config_item *item, char *page)
 673{
 674	struct se_portal_group *se_tpg = attrib_to_tpg(item);
 675	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, struct tcm_loop_tpg,
 676						   tl_se_tpg);
 677
 678	return sprintf(page, "%d\n", tl_tpg->tl_fabric_prot_type);
 679}
 680
 681static ssize_t tcm_loop_tpg_attrib_fabric_prot_type_store(
 682		struct config_item *item, const char *page, size_t count)
 683{
 684	struct se_portal_group *se_tpg = attrib_to_tpg(item);
 685	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg, struct tcm_loop_tpg,
 686						   tl_se_tpg);
 687	unsigned long val;
 688	int ret = kstrtoul(page, 0, &val);
 689
 690	if (ret) {
 691		pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret);
 692		return ret;
 693	}
 694	if (val != 0 && val != 1 && val != 3) {
 695		pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val);
 696		return -EINVAL;
 697	}
 698	tl_tpg->tl_fabric_prot_type = val;
 699
 700	return count;
 701}
 702
 703CONFIGFS_ATTR(tcm_loop_tpg_attrib_, fabric_prot_type);
 704
 705static struct configfs_attribute *tcm_loop_tpg_attrib_attrs[] = {
 706	&tcm_loop_tpg_attrib_attr_fabric_prot_type,
 707	NULL,
 708};
 709
 710/* Start items for tcm_loop_nexus_cit */
 711
 712static int tcm_loop_alloc_sess_cb(struct se_portal_group *se_tpg,
 713				  struct se_session *se_sess, void *p)
 714{
 715	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 716					struct tcm_loop_tpg, tl_se_tpg);
 717
 718	tl_tpg->tl_nexus = p;
 719	return 0;
 720}
 721
 722static int tcm_loop_make_nexus(
 723	struct tcm_loop_tpg *tl_tpg,
 724	const char *name)
 725{
 726	struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
 727	struct tcm_loop_nexus *tl_nexus;
 728	int ret;
 729
 730	if (tl_tpg->tl_nexus) {
 731		pr_debug("tl_tpg->tl_nexus already exists\n");
 732		return -EEXIST;
 733	}
 734
 735	tl_nexus = kzalloc(sizeof(*tl_nexus), GFP_KERNEL);
 736	if (!tl_nexus)
 737		return -ENOMEM;
 738
 739	tl_nexus->se_sess = target_setup_session(&tl_tpg->tl_se_tpg, 0, 0,
 740					TARGET_PROT_DIN_PASS | TARGET_PROT_DOUT_PASS,
 741					name, tl_nexus, tcm_loop_alloc_sess_cb);
 742	if (IS_ERR(tl_nexus->se_sess)) {
 743		ret = PTR_ERR(tl_nexus->se_sess);
 744		kfree(tl_nexus);
 745		return ret;
 746	}
 747
 748	pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated %s Initiator Port: %s\n",
 749		 tcm_loop_dump_proto_id(tl_hba), name);
 750	return 0;
 751}
 752
 753static int tcm_loop_drop_nexus(
 754	struct tcm_loop_tpg *tpg)
 755{
 756	struct se_session *se_sess;
 757	struct tcm_loop_nexus *tl_nexus;
 758
 759	tl_nexus = tpg->tl_nexus;
 760	if (!tl_nexus)
 761		return -ENODEV;
 762
 763	se_sess = tl_nexus->se_sess;
 764	if (!se_sess)
 765		return -ENODEV;
 766
 767	if (atomic_read(&tpg->tl_tpg_port_count)) {
 768		pr_err("Unable to remove TCM_Loop I_T Nexus with active TPG port count: %d\n",
 769		       atomic_read(&tpg->tl_tpg_port_count));
 770		return -EPERM;
 771	}
 772
 773	pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated %s Initiator Port: %s\n",
 774		 tcm_loop_dump_proto_id(tpg->tl_hba),
 775		 tl_nexus->se_sess->se_node_acl->initiatorname);
 776	/*
 777	 * Release the SCSI I_T Nexus to the emulated Target Port
 778	 */
 779	target_remove_session(se_sess);
 780	tpg->tl_nexus = NULL;
 781	kfree(tl_nexus);
 782	return 0;
 783}
 784
 785/* End items for tcm_loop_nexus_cit */
 786
 787static ssize_t tcm_loop_tpg_nexus_show(struct config_item *item, char *page)
 788{
 789	struct se_portal_group *se_tpg = to_tpg(item);
 790	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 791			struct tcm_loop_tpg, tl_se_tpg);
 792	struct tcm_loop_nexus *tl_nexus;
 793	ssize_t ret;
 794
 795	tl_nexus = tl_tpg->tl_nexus;
 796	if (!tl_nexus)
 797		return -ENODEV;
 798
 799	ret = snprintf(page, PAGE_SIZE, "%s\n",
 800		tl_nexus->se_sess->se_node_acl->initiatorname);
 801
 802	return ret;
 803}
 804
 805static ssize_t tcm_loop_tpg_nexus_store(struct config_item *item,
 806		const char *page, size_t count)
 807{
 808	struct se_portal_group *se_tpg = to_tpg(item);
 809	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 810			struct tcm_loop_tpg, tl_se_tpg);
 811	struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
 812	unsigned char i_port[TL_WWN_ADDR_LEN], *ptr, *port_ptr;
 813	int ret;
 814	/*
 815	 * Shutdown the active I_T nexus if 'NULL' is passed..
 816	 */
 817	if (!strncmp(page, "NULL", 4)) {
 818		ret = tcm_loop_drop_nexus(tl_tpg);
 819		return (!ret) ? count : ret;
 820	}
 821	/*
 822	 * Otherwise make sure the passed virtual Initiator port WWN matches
 823	 * the fabric protocol_id set in tcm_loop_make_scsi_hba(), and call
 824	 * tcm_loop_make_nexus()
 825	 */
 826	if (strlen(page) >= TL_WWN_ADDR_LEN) {
 827		pr_err("Emulated NAA Sas Address: %s, exceeds max: %d\n",
 828		       page, TL_WWN_ADDR_LEN);
 829		return -EINVAL;
 830	}
 831	snprintf(&i_port[0], TL_WWN_ADDR_LEN, "%s", page);
 832
 833	ptr = strstr(i_port, "naa.");
 834	if (ptr) {
 835		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_SAS) {
 836			pr_err("Passed SAS Initiator Port %s does not match target port protoid: %s\n",
 837			       i_port, tcm_loop_dump_proto_id(tl_hba));
 838			return -EINVAL;
 839		}
 840		port_ptr = &i_port[0];
 841		goto check_newline;
 842	}
 843	ptr = strstr(i_port, "fc.");
 844	if (ptr) {
 845		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_FCP) {
 846			pr_err("Passed FCP Initiator Port %s does not match target port protoid: %s\n",
 847			       i_port, tcm_loop_dump_proto_id(tl_hba));
 848			return -EINVAL;
 849		}
 850		port_ptr = &i_port[3]; /* Skip over "fc." */
 851		goto check_newline;
 852	}
 853	ptr = strstr(i_port, "iqn.");
 854	if (ptr) {
 855		if (tl_hba->tl_proto_id != SCSI_PROTOCOL_ISCSI) {
 856			pr_err("Passed iSCSI Initiator Port %s does not match target port protoid: %s\n",
 857			       i_port, tcm_loop_dump_proto_id(tl_hba));
 858			return -EINVAL;
 859		}
 860		port_ptr = &i_port[0];
 861		goto check_newline;
 862	}
 863	pr_err("Unable to locate prefix for emulated Initiator Port: %s\n",
 864	       i_port);
 865	return -EINVAL;
 866	/*
 867	 * Clear any trailing newline for the NAA WWN
 868	 */
 869check_newline:
 870	if (i_port[strlen(i_port)-1] == '\n')
 871		i_port[strlen(i_port)-1] = '\0';
 872
 873	ret = tcm_loop_make_nexus(tl_tpg, port_ptr);
 874	if (ret < 0)
 875		return ret;
 876
 877	return count;
 878}
 879
 880static ssize_t tcm_loop_tpg_transport_status_show(struct config_item *item,
 881		char *page)
 882{
 883	struct se_portal_group *se_tpg = to_tpg(item);
 884	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 885			struct tcm_loop_tpg, tl_se_tpg);
 886	const char *status = NULL;
 887	ssize_t ret = -EINVAL;
 888
 889	switch (tl_tpg->tl_transport_status) {
 890	case TCM_TRANSPORT_ONLINE:
 891		status = "online";
 892		break;
 893	case TCM_TRANSPORT_OFFLINE:
 894		status = "offline";
 895		break;
 896	default:
 897		break;
 898	}
 899
 900	if (status)
 901		ret = snprintf(page, PAGE_SIZE, "%s\n", status);
 902
 903	return ret;
 904}
 905
 906static ssize_t tcm_loop_tpg_transport_status_store(struct config_item *item,
 907		const char *page, size_t count)
 908{
 909	struct se_portal_group *se_tpg = to_tpg(item);
 910	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 911			struct tcm_loop_tpg, tl_se_tpg);
 912
 913	if (!strncmp(page, "online", 6)) {
 914		tl_tpg->tl_transport_status = TCM_TRANSPORT_ONLINE;
 915		return count;
 916	}
 917	if (!strncmp(page, "offline", 7)) {
 918		tl_tpg->tl_transport_status = TCM_TRANSPORT_OFFLINE;
 919		if (tl_tpg->tl_nexus) {
 920			struct se_session *tl_sess = tl_tpg->tl_nexus->se_sess;
 921
 922			core_allocate_nexus_loss_ua(tl_sess->se_node_acl);
 923		}
 924		return count;
 925	}
 926	return -EINVAL;
 927}
 928
 929static ssize_t tcm_loop_tpg_address_show(struct config_item *item,
 930					 char *page)
 931{
 932	struct se_portal_group *se_tpg = to_tpg(item);
 933	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 934			struct tcm_loop_tpg, tl_se_tpg);
 935	struct tcm_loop_hba *tl_hba = tl_tpg->tl_hba;
 936
 937	if (!tl_hba->sh)
 938		return -ENODEV;
 939
 940	return snprintf(page, PAGE_SIZE, "%d:0:%d\n",
 941			tl_hba->sh->host_no, tl_tpg->tl_tpgt);
 942}
 943
 944CONFIGFS_ATTR(tcm_loop_tpg_, nexus);
 945CONFIGFS_ATTR(tcm_loop_tpg_, transport_status);
 946CONFIGFS_ATTR_RO(tcm_loop_tpg_, address);
 947
 948static struct configfs_attribute *tcm_loop_tpg_attrs[] = {
 949	&tcm_loop_tpg_attr_nexus,
 950	&tcm_loop_tpg_attr_transport_status,
 951	&tcm_loop_tpg_attr_address,
 952	NULL,
 953};
 954
 955/* Start items for tcm_loop_naa_cit */
 956
 957static struct se_portal_group *tcm_loop_make_naa_tpg(struct se_wwn *wwn,
 958						     const char *name)
 959{
 960	struct tcm_loop_hba *tl_hba = container_of(wwn,
 961			struct tcm_loop_hba, tl_hba_wwn);
 962	struct tcm_loop_tpg *tl_tpg;
 963	int ret;
 964	unsigned long tpgt;
 965
 966	if (strstr(name, "tpgt_") != name) {
 967		pr_err("Unable to locate \"tpgt_#\" directory group\n");
 968		return ERR_PTR(-EINVAL);
 969	}
 970	if (kstrtoul(name+5, 10, &tpgt))
 971		return ERR_PTR(-EINVAL);
 972
 973	if (tpgt >= TL_TPGS_PER_HBA) {
 974		pr_err("Passed tpgt: %lu exceeds TL_TPGS_PER_HBA: %u\n",
 975		       tpgt, TL_TPGS_PER_HBA);
 976		return ERR_PTR(-EINVAL);
 977	}
 978	tl_tpg = &tl_hba->tl_hba_tpgs[tpgt];
 979	tl_tpg->tl_hba = tl_hba;
 980	tl_tpg->tl_tpgt = tpgt;
 981	/*
 982	 * Register the tl_tpg as a emulated TCM Target Endpoint
 983	 */
 984	ret = core_tpg_register(wwn, &tl_tpg->tl_se_tpg, tl_hba->tl_proto_id);
 985	if (ret < 0)
 986		return ERR_PTR(-ENOMEM);
 987
 988	pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s Target Port %s,t,0x%04lx\n",
 989		 tcm_loop_dump_proto_id(tl_hba),
 990		 config_item_name(&wwn->wwn_group.cg_item), tpgt);
 991	return &tl_tpg->tl_se_tpg;
 992}
 993
 994static void tcm_loop_drop_naa_tpg(
 995	struct se_portal_group *se_tpg)
 996{
 997	struct se_wwn *wwn = se_tpg->se_tpg_wwn;
 998	struct tcm_loop_tpg *tl_tpg = container_of(se_tpg,
 999				struct tcm_loop_tpg, tl_se_tpg);
1000	struct tcm_loop_hba *tl_hba;
1001	unsigned short tpgt;
1002
1003	tl_hba = tl_tpg->tl_hba;
1004	tpgt = tl_tpg->tl_tpgt;
1005	/*
1006	 * Release the I_T Nexus for the Virtual target link if present
1007	 */
1008	tcm_loop_drop_nexus(tl_tpg);
1009	/*
1010	 * Deregister the tl_tpg as a emulated TCM Target Endpoint
1011	 */
1012	core_tpg_deregister(se_tpg);
1013
1014	tl_tpg->tl_hba = NULL;
1015	tl_tpg->tl_tpgt = 0;
1016
1017	pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s Target Port %s,t,0x%04x\n",
1018		 tcm_loop_dump_proto_id(tl_hba),
1019		 config_item_name(&wwn->wwn_group.cg_item), tpgt);
1020}
1021
1022/* End items for tcm_loop_naa_cit */
1023
1024/* Start items for tcm_loop_cit */
1025
1026static struct se_wwn *tcm_loop_make_scsi_hba(
1027	struct target_fabric_configfs *tf,
1028	struct config_group *group,
1029	const char *name)
1030{
1031	struct tcm_loop_hba *tl_hba;
1032	struct Scsi_Host *sh;
1033	char *ptr;
1034	int ret, off = 0;
1035
1036	tl_hba = kzalloc(sizeof(*tl_hba), GFP_KERNEL);
1037	if (!tl_hba)
1038		return ERR_PTR(-ENOMEM);
1039
1040	/*
1041	 * Determine the emulated Protocol Identifier and Target Port Name
1042	 * based on the incoming configfs directory name.
1043	 */
1044	ptr = strstr(name, "naa.");
1045	if (ptr) {
1046		tl_hba->tl_proto_id = SCSI_PROTOCOL_SAS;
1047		goto check_len;
1048	}
1049	ptr = strstr(name, "fc.");
1050	if (ptr) {
1051		tl_hba->tl_proto_id = SCSI_PROTOCOL_FCP;
1052		off = 3; /* Skip over "fc." */
1053		goto check_len;
1054	}
1055	ptr = strstr(name, "iqn.");
1056	if (!ptr) {
1057		pr_err("Unable to locate prefix for emulated Target Port: %s\n",
1058		       name);
1059		ret = -EINVAL;
1060		goto out;
1061	}
1062	tl_hba->tl_proto_id = SCSI_PROTOCOL_ISCSI;
1063
1064check_len:
1065	if (strlen(name) >= TL_WWN_ADDR_LEN) {
1066		pr_err("Emulated NAA %s Address: %s, exceeds max: %d\n",
1067		       name, tcm_loop_dump_proto_id(tl_hba), TL_WWN_ADDR_LEN);
1068		ret = -EINVAL;
1069		goto out;
1070	}
1071	snprintf(&tl_hba->tl_wwn_address[0], TL_WWN_ADDR_LEN, "%s", &name[off]);
1072
1073	/*
1074	 * Call device_register(tl_hba->dev) to register the emulated
1075	 * Linux/SCSI LLD of type struct Scsi_Host at tl_hba->sh after
1076	 * device_register() callbacks in tcm_loop_driver_probe()
1077	 */
1078	ret = tcm_loop_setup_hba_bus(tl_hba, tcm_loop_hba_no_cnt);
1079	if (ret)
1080		return ERR_PTR(ret);
1081
1082	sh = tl_hba->sh;
1083	tcm_loop_hba_no_cnt++;
1084	pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target %s Address: %s at Linux/SCSI Host ID: %d\n",
1085		 tcm_loop_dump_proto_id(tl_hba), name, sh->host_no);
1086	return &tl_hba->tl_hba_wwn;
1087out:
1088	kfree(tl_hba);
1089	return ERR_PTR(ret);
1090}
1091
1092static void tcm_loop_drop_scsi_hba(
1093	struct se_wwn *wwn)
1094{
1095	struct tcm_loop_hba *tl_hba = container_of(wwn,
1096				struct tcm_loop_hba, tl_hba_wwn);
1097
1098	pr_debug("TCM_Loop_ConfigFS: Deallocating emulated Target %s Address: %s at Linux/SCSI Host ID: %d\n",
1099		 tcm_loop_dump_proto_id(tl_hba), tl_hba->tl_wwn_address,
1100		 tl_hba->sh->host_no);
1101	/*
1102	 * Call device_unregister() on the original tl_hba->dev.
1103	 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will
1104	 * release *tl_hba;
1105	 */
1106	device_unregister(&tl_hba->dev);
1107}
1108
1109/* Start items for tcm_loop_cit */
1110static ssize_t tcm_loop_wwn_version_show(struct config_item *item, char *page)
1111{
1112	return sprintf(page, "TCM Loopback Fabric module %s\n", TCM_LOOP_VERSION);
1113}
1114
1115CONFIGFS_ATTR_RO(tcm_loop_wwn_, version);
1116
1117static struct configfs_attribute *tcm_loop_wwn_attrs[] = {
1118	&tcm_loop_wwn_attr_version,
1119	NULL,
1120};
1121
1122/* End items for tcm_loop_cit */
1123
1124static const struct target_core_fabric_ops loop_ops = {
1125	.module				= THIS_MODULE,
1126	.fabric_name			= "loopback",
1127	.tpg_get_wwn			= tcm_loop_get_endpoint_wwn,
1128	.tpg_get_tag			= tcm_loop_get_tag,
1129	.tpg_check_demo_mode		= tcm_loop_check_demo_mode,
1130	.tpg_check_prot_fabric_only	= tcm_loop_check_prot_fabric_only,
1131	.check_stop_free		= tcm_loop_check_stop_free,
1132	.release_cmd			= tcm_loop_release_cmd,
1133	.sess_get_index			= tcm_loop_sess_get_index,
1134	.write_pending			= tcm_loop_write_pending,
1135	.get_cmd_state			= tcm_loop_get_cmd_state,
1136	.queue_data_in			= tcm_loop_queue_data_in,
1137	.queue_status			= tcm_loop_queue_status,
1138	.queue_tm_rsp			= tcm_loop_queue_tm_rsp,
1139	.aborted_task			= tcm_loop_aborted_task,
1140	.fabric_make_wwn		= tcm_loop_make_scsi_hba,
1141	.fabric_drop_wwn		= tcm_loop_drop_scsi_hba,
1142	.fabric_make_tpg		= tcm_loop_make_naa_tpg,
1143	.fabric_drop_tpg		= tcm_loop_drop_naa_tpg,
1144	.fabric_post_link		= tcm_loop_port_link,
1145	.fabric_pre_unlink		= tcm_loop_port_unlink,
1146	.tfc_wwn_attrs			= tcm_loop_wwn_attrs,
1147	.tfc_tpg_base_attrs		= tcm_loop_tpg_attrs,
1148	.tfc_tpg_attrib_attrs		= tcm_loop_tpg_attrib_attrs,
1149	.default_submit_type		= TARGET_QUEUE_SUBMIT,
1150	.direct_submit_supp		= 0,
1151};
1152
1153static int __init tcm_loop_fabric_init(void)
1154{
1155	int ret = -ENOMEM;
1156
1157	tcm_loop_cmd_cache = kmem_cache_create("tcm_loop_cmd_cache",
1158				sizeof(struct tcm_loop_cmd),
1159				__alignof__(struct tcm_loop_cmd),
1160				0, NULL);
1161	if (!tcm_loop_cmd_cache) {
1162		pr_debug("kmem_cache_create() for tcm_loop_cmd_cache failed\n");
1163		goto out;
1164	}
1165
1166	ret = tcm_loop_alloc_core_bus();
1167	if (ret)
1168		goto out_destroy_cache;
1169
1170	ret = target_register_template(&loop_ops);
1171	if (ret)
1172		goto out_release_core_bus;
1173
1174	return 0;
1175
1176out_release_core_bus:
1177	tcm_loop_release_core_bus();
1178out_destroy_cache:
1179	kmem_cache_destroy(tcm_loop_cmd_cache);
1180out:
1181	return ret;
1182}
1183
1184static void __exit tcm_loop_fabric_exit(void)
1185{
1186	target_unregister_template(&loop_ops);
1187	tcm_loop_release_core_bus();
1188	kmem_cache_destroy(tcm_loop_cmd_cache);
1189}
1190
1191MODULE_DESCRIPTION("TCM loopback virtual Linux/SCSI fabric module");
1192MODULE_AUTHOR("Nicholas A. Bellinger <nab@risingtidesystems.com>");
1193MODULE_LICENSE("GPL");
1194module_init(tcm_loop_fabric_init);
1195module_exit(tcm_loop_fabric_exit);