1 /*******************************************************************************
3 * This file contains the Linux/SCSI LLD virtual SCSI initiator driver
4 * for emulated SAS initiator ports
6 * © Copyright 2011-2013 Datera, Inc.
8 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
10 * Author: Nicholas A. Bellinger <nab@risingtidesystems.com>
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.
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 ****************************************************************************/
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 <scsi/scsi.h>
30 #include <scsi/scsi_tcq.h>
31 #include <scsi/scsi_host.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_cmnd.h>
35 #include <target/target_core_base.h>
36 #include <target/target_core_fabric.h>
37 #include <target/target_core_fabric_configfs.h>
38 #include <target/target_core_configfs.h>
42 #define to_tcm_loop_hba(hba) container_of(hba, struct tcm_loop_hba, dev)
44 static const struct target_core_fabric_ops loop_ops
;
46 static struct workqueue_struct
*tcm_loop_workqueue
;
47 static struct kmem_cache
*tcm_loop_cmd_cache
;
49 static int tcm_loop_hba_no_cnt
;
51 static int tcm_loop_queue_status(struct se_cmd
*se_cmd
);
54 * Called from struct target_core_fabric_ops->check_stop_free()
56 static int tcm_loop_check_stop_free(struct se_cmd
*se_cmd
)
59 * Do not release struct se_cmd's containing a valid TMR
60 * pointer. These will be released directly in tcm_loop_device_reset()
61 * with transport_generic_free_cmd().
63 if (se_cmd
->se_cmd_flags
& SCF_SCSI_TMR_CDB
)
66 * Release the struct se_cmd, which will make a callback to release
67 * struct tcm_loop_cmd * in tcm_loop_deallocate_core_cmd()
69 transport_generic_free_cmd(se_cmd
, 0);
73 static void tcm_loop_release_cmd(struct se_cmd
*se_cmd
)
75 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
76 struct tcm_loop_cmd
, tl_se_cmd
);
78 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
81 static int tcm_loop_show_info(struct seq_file
*m
, struct Scsi_Host
*host
)
83 seq_printf(m
, "tcm_loop_proc_info()\n");
87 static int tcm_loop_driver_probe(struct device
*);
88 static int tcm_loop_driver_remove(struct device
*);
90 static int pseudo_lld_bus_match(struct device
*dev
,
91 struct device_driver
*dev_driver
)
96 static struct bus_type tcm_loop_lld_bus
= {
97 .name
= "tcm_loop_bus",
98 .match
= pseudo_lld_bus_match
,
99 .probe
= tcm_loop_driver_probe
,
100 .remove
= tcm_loop_driver_remove
,
103 static struct device_driver tcm_loop_driverfs
= {
105 .bus
= &tcm_loop_lld_bus
,
108 * Used with root_device_register() in tcm_loop_alloc_core_bus() below
110 static struct device
*tcm_loop_primary
;
112 static void tcm_loop_submission_work(struct work_struct
*work
)
114 struct tcm_loop_cmd
*tl_cmd
=
115 container_of(work
, struct tcm_loop_cmd
, work
);
116 struct se_cmd
*se_cmd
= &tl_cmd
->tl_se_cmd
;
117 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
118 struct tcm_loop_nexus
*tl_nexus
;
119 struct tcm_loop_hba
*tl_hba
;
120 struct tcm_loop_tpg
*tl_tpg
;
121 struct scatterlist
*sgl_bidi
= NULL
;
122 u32 sgl_bidi_count
= 0, transfer_length
;
125 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
126 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
129 * Ensure that this tl_tpg reference from the incoming sc->device->id
130 * has already been configured via tcm_loop_make_naa_tpg().
132 if (!tl_tpg
->tl_hba
) {
133 set_host_byte(sc
, DID_NO_CONNECT
);
136 if (tl_tpg
->tl_transport_status
== TCM_TRANSPORT_OFFLINE
) {
137 set_host_byte(sc
, DID_TRANSPORT_DISRUPTED
);
140 tl_nexus
= tl_tpg
->tl_nexus
;
142 scmd_printk(KERN_ERR
, sc
, "TCM_Loop I_T Nexus"
143 " does not exist\n");
144 set_host_byte(sc
, DID_ERROR
);
147 if (scsi_bidi_cmnd(sc
)) {
148 struct scsi_data_buffer
*sdb
= scsi_in(sc
);
150 sgl_bidi
= sdb
->table
.sgl
;
151 sgl_bidi_count
= sdb
->table
.nents
;
152 se_cmd
->se_cmd_flags
|= SCF_BIDI
;
156 transfer_length
= scsi_transfer_length(sc
);
157 if (!scsi_prot_sg_count(sc
) &&
158 scsi_get_prot_op(sc
) != SCSI_PROT_NORMAL
) {
159 se_cmd
->prot_pto
= true;
161 * loopback transport doesn't support
162 * WRITE_GENERATE, READ_STRIP protection
163 * information operations, go ahead unprotected.
165 transfer_length
= scsi_bufflen(sc
);
168 rc
= target_submit_cmd_map_sgls(se_cmd
, tl_nexus
->se_sess
, sc
->cmnd
,
169 &tl_cmd
->tl_sense_buf
[0], tl_cmd
->sc
->device
->lun
,
170 transfer_length
, TCM_SIMPLE_TAG
,
171 sc
->sc_data_direction
, 0,
172 scsi_sglist(sc
), scsi_sg_count(sc
),
173 sgl_bidi
, sgl_bidi_count
,
174 scsi_prot_sglist(sc
), scsi_prot_sg_count(sc
));
176 set_host_byte(sc
, DID_NO_CONNECT
);
182 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
188 * ->queuecommand can be and usually is called from interrupt context, so
189 * defer the actual submission to a workqueue.
191 static int tcm_loop_queuecommand(struct Scsi_Host
*sh
, struct scsi_cmnd
*sc
)
193 struct tcm_loop_cmd
*tl_cmd
;
195 pr_debug("tcm_loop_queuecommand() %d:%d:%d:%llu got CDB: 0x%02x"
196 " scsi_buf_len: %u\n", sc
->device
->host
->host_no
,
197 sc
->device
->id
, sc
->device
->channel
, sc
->device
->lun
,
198 sc
->cmnd
[0], scsi_bufflen(sc
));
200 tl_cmd
= kmem_cache_zalloc(tcm_loop_cmd_cache
, GFP_ATOMIC
);
202 pr_err("Unable to allocate struct tcm_loop_cmd\n");
203 set_host_byte(sc
, DID_ERROR
);
209 tl_cmd
->sc_cmd_tag
= sc
->request
->tag
;
210 INIT_WORK(&tl_cmd
->work
, tcm_loop_submission_work
);
211 queue_work(tcm_loop_workqueue
, &tl_cmd
->work
);
216 * Called from SCSI EH process context to issue a LUN_RESET TMR
217 * to struct scsi_device
219 static int tcm_loop_issue_tmr(struct tcm_loop_tpg
*tl_tpg
,
220 int lun
, int task
, enum tcm_tmreq_table tmr
)
222 struct se_cmd
*se_cmd
= NULL
;
223 struct se_session
*se_sess
;
224 struct se_portal_group
*se_tpg
;
225 struct tcm_loop_nexus
*tl_nexus
;
226 struct tcm_loop_cmd
*tl_cmd
= NULL
;
227 struct tcm_loop_tmr
*tl_tmr
= NULL
;
228 int ret
= TMR_FUNCTION_FAILED
, rc
;
231 * Locate the tl_nexus and se_sess pointers
233 tl_nexus
= tl_tpg
->tl_nexus
;
235 pr_err("Unable to perform device reset without"
236 " active I_T Nexus\n");
240 tl_cmd
= kmem_cache_zalloc(tcm_loop_cmd_cache
, GFP_KERNEL
);
242 pr_err("Unable to allocate memory for tl_cmd\n");
246 tl_tmr
= kzalloc(sizeof(struct tcm_loop_tmr
), GFP_KERNEL
);
248 pr_err("Unable to allocate memory for tl_tmr\n");
251 init_waitqueue_head(&tl_tmr
->tl_tmr_wait
);
253 se_cmd
= &tl_cmd
->tl_se_cmd
;
254 se_tpg
= &tl_tpg
->tl_se_tpg
;
255 se_sess
= tl_tpg
->tl_nexus
->se_sess
;
257 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
259 transport_init_se_cmd(se_cmd
, se_tpg
->se_tpg_tfo
, se_sess
, 0,
260 DMA_NONE
, TCM_SIMPLE_TAG
,
261 &tl_cmd
->tl_sense_buf
[0]);
263 rc
= core_tmr_alloc_req(se_cmd
, tl_tmr
, tmr
, GFP_KERNEL
);
267 if (tmr
== TMR_ABORT_TASK
)
268 se_cmd
->se_tmr_req
->ref_task_tag
= task
;
271 * Locate the underlying TCM struct se_lun
273 if (transport_lookup_tmr_lun(se_cmd
, lun
) < 0) {
274 ret
= TMR_LUN_DOES_NOT_EXIST
;
278 * Queue the TMR to TCM Core and sleep waiting for
279 * tcm_loop_queue_tm_rsp() to wake us up.
281 transport_generic_handle_tmr(se_cmd
);
282 wait_event(tl_tmr
->tl_tmr_wait
, atomic_read(&tl_tmr
->tmr_complete
));
284 * The TMR LUN_RESET has completed, check the response status and
285 * then release allocations.
287 ret
= se_cmd
->se_tmr_req
->response
;
290 transport_generic_free_cmd(se_cmd
, 1);
292 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
297 static int tcm_loop_abort_task(struct scsi_cmnd
*sc
)
299 struct tcm_loop_hba
*tl_hba
;
300 struct tcm_loop_tpg
*tl_tpg
;
304 * Locate the tcm_loop_hba_t pointer
306 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
307 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
308 ret
= tcm_loop_issue_tmr(tl_tpg
, sc
->device
->lun
,
309 sc
->request
->tag
, TMR_ABORT_TASK
);
310 return (ret
== TMR_FUNCTION_COMPLETE
) ? SUCCESS
: FAILED
;
314 * Called from SCSI EH process context to issue a LUN_RESET TMR
315 * to struct scsi_device
317 static int tcm_loop_device_reset(struct scsi_cmnd
*sc
)
319 struct tcm_loop_hba
*tl_hba
;
320 struct tcm_loop_tpg
*tl_tpg
;
324 * Locate the tcm_loop_hba_t pointer
326 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
327 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
329 ret
= tcm_loop_issue_tmr(tl_tpg
, sc
->device
->lun
,
331 return (ret
== TMR_FUNCTION_COMPLETE
) ? SUCCESS
: FAILED
;
334 static int tcm_loop_target_reset(struct scsi_cmnd
*sc
)
336 struct tcm_loop_hba
*tl_hba
;
337 struct tcm_loop_tpg
*tl_tpg
;
340 * Locate the tcm_loop_hba_t pointer
342 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
344 pr_err("Unable to perform device reset without"
345 " active I_T Nexus\n");
349 * Locate the tl_tpg pointer from TargetID in sc->device->id
351 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
353 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_ONLINE
;
359 static int tcm_loop_slave_alloc(struct scsi_device
*sd
)
361 set_bit(QUEUE_FLAG_BIDI
, &sd
->request_queue
->queue_flags
);
365 static struct scsi_host_template tcm_loop_driver_template
= {
366 .show_info
= tcm_loop_show_info
,
367 .proc_name
= "tcm_loopback",
368 .name
= "TCM_Loopback",
369 .queuecommand
= tcm_loop_queuecommand
,
370 .change_queue_depth
= scsi_change_queue_depth
,
371 .eh_abort_handler
= tcm_loop_abort_task
,
372 .eh_device_reset_handler
= tcm_loop_device_reset
,
373 .eh_target_reset_handler
= tcm_loop_target_reset
,
378 .max_sectors
= 0xFFFF,
379 .use_clustering
= DISABLE_CLUSTERING
,
380 .slave_alloc
= tcm_loop_slave_alloc
,
381 .module
= THIS_MODULE
,
383 .track_queue_depth
= 1,
386 static int tcm_loop_driver_probe(struct device
*dev
)
388 struct tcm_loop_hba
*tl_hba
;
389 struct Scsi_Host
*sh
;
390 int error
, host_prot
;
392 tl_hba
= to_tcm_loop_hba(dev
);
394 sh
= scsi_host_alloc(&tcm_loop_driver_template
,
395 sizeof(struct tcm_loop_hba
));
397 pr_err("Unable to allocate struct scsi_host\n");
403 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata
405 *((struct tcm_loop_hba
**)sh
->hostdata
) = tl_hba
;
407 * Setup single ID, Channel and LUN for now..
412 sh
->max_cmd_len
= SCSI_MAX_VARLEN_CDB_SIZE
;
414 host_prot
= SHOST_DIF_TYPE1_PROTECTION
| SHOST_DIF_TYPE2_PROTECTION
|
415 SHOST_DIF_TYPE3_PROTECTION
| SHOST_DIX_TYPE1_PROTECTION
|
416 SHOST_DIX_TYPE2_PROTECTION
| SHOST_DIX_TYPE3_PROTECTION
;
418 scsi_host_set_prot(sh
, host_prot
);
419 scsi_host_set_guard(sh
, SHOST_DIX_GUARD_CRC
);
421 error
= scsi_add_host(sh
, &tl_hba
->dev
);
423 pr_err("%s: scsi_add_host failed\n", __func__
);
430 static int tcm_loop_driver_remove(struct device
*dev
)
432 struct tcm_loop_hba
*tl_hba
;
433 struct Scsi_Host
*sh
;
435 tl_hba
= to_tcm_loop_hba(dev
);
438 scsi_remove_host(sh
);
443 static void tcm_loop_release_adapter(struct device
*dev
)
445 struct tcm_loop_hba
*tl_hba
= to_tcm_loop_hba(dev
);
451 * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c
453 static int tcm_loop_setup_hba_bus(struct tcm_loop_hba
*tl_hba
, int tcm_loop_host_id
)
457 tl_hba
->dev
.bus
= &tcm_loop_lld_bus
;
458 tl_hba
->dev
.parent
= tcm_loop_primary
;
459 tl_hba
->dev
.release
= &tcm_loop_release_adapter
;
460 dev_set_name(&tl_hba
->dev
, "tcm_loop_adapter_%d", tcm_loop_host_id
);
462 ret
= device_register(&tl_hba
->dev
);
464 pr_err("device_register() failed for"
465 " tl_hba->dev: %d\n", ret
);
473 * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated
476 static int tcm_loop_alloc_core_bus(void)
480 tcm_loop_primary
= root_device_register("tcm_loop_0");
481 if (IS_ERR(tcm_loop_primary
)) {
482 pr_err("Unable to allocate tcm_loop_primary\n");
483 return PTR_ERR(tcm_loop_primary
);
486 ret
= bus_register(&tcm_loop_lld_bus
);
488 pr_err("bus_register() failed for tcm_loop_lld_bus\n");
492 ret
= driver_register(&tcm_loop_driverfs
);
494 pr_err("driver_register() failed for"
495 "tcm_loop_driverfs\n");
499 pr_debug("Initialized TCM Loop Core Bus\n");
503 bus_unregister(&tcm_loop_lld_bus
);
505 root_device_unregister(tcm_loop_primary
);
509 static void tcm_loop_release_core_bus(void)
511 driver_unregister(&tcm_loop_driverfs
);
512 bus_unregister(&tcm_loop_lld_bus
);
513 root_device_unregister(tcm_loop_primary
);
515 pr_debug("Releasing TCM Loop Core BUS\n");
518 static char *tcm_loop_get_fabric_name(void)
523 static u8
tcm_loop_get_fabric_proto_ident(struct se_portal_group
*se_tpg
)
525 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
526 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
528 * tl_proto_id is set at tcm_loop_configfs.c:tcm_loop_make_scsi_hba()
529 * time based on the protocol dependent prefix of the passed configfs group.
531 * Based upon tl_proto_id, TCM_Loop emulates the requested fabric
532 * ProtocolID using target_core_fabric_lib.c symbols.
534 switch (tl_hba
->tl_proto_id
) {
535 case SCSI_PROTOCOL_SAS
:
536 return sas_get_fabric_proto_ident(se_tpg
);
537 case SCSI_PROTOCOL_FCP
:
538 return fc_get_fabric_proto_ident(se_tpg
);
539 case SCSI_PROTOCOL_ISCSI
:
540 return iscsi_get_fabric_proto_ident(se_tpg
);
542 pr_err("Unknown tl_proto_id: 0x%02x, using"
543 " SAS emulation\n", tl_hba
->tl_proto_id
);
547 return sas_get_fabric_proto_ident(se_tpg
);
550 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group
*se_tpg
)
552 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
554 * Return the passed NAA identifier for the SAS Target Port
556 return &tl_tpg
->tl_hba
->tl_wwn_address
[0];
559 static u16
tcm_loop_get_tag(struct se_portal_group
*se_tpg
)
561 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
563 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83
564 * to represent the SCSI Target Port.
566 return tl_tpg
->tl_tpgt
;
569 static u32
tcm_loop_get_default_depth(struct se_portal_group
*se_tpg
)
574 static u32
tcm_loop_get_pr_transport_id(
575 struct se_portal_group
*se_tpg
,
576 struct se_node_acl
*se_nacl
,
577 struct t10_pr_registration
*pr_reg
,
581 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
582 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
584 switch (tl_hba
->tl_proto_id
) {
585 case SCSI_PROTOCOL_SAS
:
586 return sas_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
588 case SCSI_PROTOCOL_FCP
:
589 return fc_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
591 case SCSI_PROTOCOL_ISCSI
:
592 return iscsi_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
595 pr_err("Unknown tl_proto_id: 0x%02x, using"
596 " SAS emulation\n", tl_hba
->tl_proto_id
);
600 return sas_get_pr_transport_id(se_tpg
, se_nacl
, pr_reg
,
604 static u32
tcm_loop_get_pr_transport_id_len(
605 struct se_portal_group
*se_tpg
,
606 struct se_node_acl
*se_nacl
,
607 struct t10_pr_registration
*pr_reg
,
610 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
611 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
613 switch (tl_hba
->tl_proto_id
) {
614 case SCSI_PROTOCOL_SAS
:
615 return sas_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
617 case SCSI_PROTOCOL_FCP
:
618 return fc_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
620 case SCSI_PROTOCOL_ISCSI
:
621 return iscsi_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
624 pr_err("Unknown tl_proto_id: 0x%02x, using"
625 " SAS emulation\n", tl_hba
->tl_proto_id
);
629 return sas_get_pr_transport_id_len(se_tpg
, se_nacl
, pr_reg
,
634 * Used for handling SCSI fabric dependent TransportIDs in SPC-3 and above
635 * Persistent Reservation SPEC_I_PT=1 and PROUT REGISTER_AND_MOVE operations.
637 static char *tcm_loop_parse_pr_out_transport_id(
638 struct se_portal_group
*se_tpg
,
641 char **port_nexus_ptr
)
643 struct tcm_loop_tpg
*tl_tpg
= se_tpg
->se_tpg_fabric_ptr
;
644 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
646 switch (tl_hba
->tl_proto_id
) {
647 case SCSI_PROTOCOL_SAS
:
648 return sas_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
650 case SCSI_PROTOCOL_FCP
:
651 return fc_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
653 case SCSI_PROTOCOL_ISCSI
:
654 return iscsi_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
657 pr_err("Unknown tl_proto_id: 0x%02x, using"
658 " SAS emulation\n", tl_hba
->tl_proto_id
);
662 return sas_parse_pr_out_transport_id(se_tpg
, buf
, out_tid_len
,
667 * Returning (1) here allows for target_core_mod struct se_node_acl to be generated
668 * based upon the incoming fabric dependent SCSI Initiator Port
670 static int tcm_loop_check_demo_mode(struct se_portal_group
*se_tpg
)
675 static int tcm_loop_check_demo_mode_cache(struct se_portal_group
*se_tpg
)
681 * Allow I_T Nexus full READ-WRITE access without explict Initiator Node ACLs for
682 * local virtual Linux/SCSI LLD passthrough into VM hypervisor guest
684 static int tcm_loop_check_demo_mode_write_protect(struct se_portal_group
*se_tpg
)
690 * Because TCM_Loop does not use explict ACLs and MappedLUNs, this will
691 * never be called for TCM_Loop by target_core_fabric_configfs.c code.
692 * It has been added here as a nop for target_fabric_tf_ops_check()
694 static int tcm_loop_check_prod_mode_write_protect(struct se_portal_group
*se_tpg
)
699 static int tcm_loop_check_prot_fabric_only(struct se_portal_group
*se_tpg
)
701 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
703 return tl_tpg
->tl_fabric_prot_type
;
706 static struct se_node_acl
*tcm_loop_tpg_alloc_fabric_acl(
707 struct se_portal_group
*se_tpg
)
709 return kzalloc(sizeof(struct se_node_acl
), GFP_KERNEL
);
712 static void tcm_loop_tpg_release_fabric_acl(
713 struct se_portal_group
*se_tpg
,
714 struct se_node_acl
*se_nacl
)
719 static u32
tcm_loop_get_inst_index(struct se_portal_group
*se_tpg
)
724 static u32
tcm_loop_sess_get_index(struct se_session
*se_sess
)
729 static void tcm_loop_set_default_node_attributes(struct se_node_acl
*se_acl
)
734 static u32
tcm_loop_get_task_tag(struct se_cmd
*se_cmd
)
736 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
737 struct tcm_loop_cmd
, tl_se_cmd
);
739 return tl_cmd
->sc_cmd_tag
;
742 static int tcm_loop_get_cmd_state(struct se_cmd
*se_cmd
)
744 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
745 struct tcm_loop_cmd
, tl_se_cmd
);
747 return tl_cmd
->sc_cmd_state
;
750 static int tcm_loop_shutdown_session(struct se_session
*se_sess
)
755 static void tcm_loop_close_session(struct se_session
*se_sess
)
760 static int tcm_loop_write_pending(struct se_cmd
*se_cmd
)
763 * Since Linux/SCSI has already sent down a struct scsi_cmnd
764 * sc->sc_data_direction of DMA_TO_DEVICE with struct scatterlist array
765 * memory, and memory has already been mapped to struct se_cmd->t_mem_list
766 * format with transport_generic_map_mem_to_cmd().
768 * We now tell TCM to add this WRITE CDB directly into the TCM storage
769 * object execution queue.
771 target_execute_cmd(se_cmd
);
775 static int tcm_loop_write_pending_status(struct se_cmd
*se_cmd
)
780 static int tcm_loop_queue_data_in(struct se_cmd
*se_cmd
)
782 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
783 struct tcm_loop_cmd
, tl_se_cmd
);
784 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
786 pr_debug("tcm_loop_queue_data_in() called for scsi_cmnd: %p"
787 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
789 sc
->result
= SAM_STAT_GOOD
;
790 set_host_byte(sc
, DID_OK
);
791 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
792 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
793 scsi_set_resid(sc
, se_cmd
->residual_count
);
798 static int tcm_loop_queue_status(struct se_cmd
*se_cmd
)
800 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
801 struct tcm_loop_cmd
, tl_se_cmd
);
802 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
804 pr_debug("tcm_loop_queue_status() called for scsi_cmnd: %p"
805 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
807 if (se_cmd
->sense_buffer
&&
808 ((se_cmd
->se_cmd_flags
& SCF_TRANSPORT_TASK_SENSE
) ||
809 (se_cmd
->se_cmd_flags
& SCF_EMULATED_TASK_SENSE
))) {
811 memcpy(sc
->sense_buffer
, se_cmd
->sense_buffer
,
812 SCSI_SENSE_BUFFERSIZE
);
813 sc
->result
= SAM_STAT_CHECK_CONDITION
;
814 set_driver_byte(sc
, DRIVER_SENSE
);
816 sc
->result
= se_cmd
->scsi_status
;
818 set_host_byte(sc
, DID_OK
);
819 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
820 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
821 scsi_set_resid(sc
, se_cmd
->residual_count
);
826 static void tcm_loop_queue_tm_rsp(struct se_cmd
*se_cmd
)
828 struct se_tmr_req
*se_tmr
= se_cmd
->se_tmr_req
;
829 struct tcm_loop_tmr
*tl_tmr
= se_tmr
->fabric_tmr_ptr
;
831 * The SCSI EH thread will be sleeping on se_tmr->tl_tmr_wait, go ahead
832 * and wake up the wait_queue_head_t in tcm_loop_device_reset()
834 atomic_set(&tl_tmr
->tmr_complete
, 1);
835 wake_up(&tl_tmr
->tl_tmr_wait
);
838 static void tcm_loop_aborted_task(struct se_cmd
*se_cmd
)
843 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba
*tl_hba
)
845 switch (tl_hba
->tl_proto_id
) {
846 case SCSI_PROTOCOL_SAS
:
848 case SCSI_PROTOCOL_FCP
:
850 case SCSI_PROTOCOL_ISCSI
:
859 /* Start items for tcm_loop_port_cit */
861 static int tcm_loop_port_link(
862 struct se_portal_group
*se_tpg
,
865 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
866 struct tcm_loop_tpg
, tl_se_tpg
);
867 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
869 atomic_inc_mb(&tl_tpg
->tl_tpg_port_count
);
871 * Add Linux/SCSI struct scsi_device by HCTL
873 scsi_add_device(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
, lun
->unpacked_lun
);
875 pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n");
879 static void tcm_loop_port_unlink(
880 struct se_portal_group
*se_tpg
,
881 struct se_lun
*se_lun
)
883 struct scsi_device
*sd
;
884 struct tcm_loop_hba
*tl_hba
;
885 struct tcm_loop_tpg
*tl_tpg
;
887 tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
, tl_se_tpg
);
888 tl_hba
= tl_tpg
->tl_hba
;
890 sd
= scsi_device_lookup(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
,
891 se_lun
->unpacked_lun
);
893 pr_err("Unable to locate struct scsi_device for %d:%d:"
894 "%d\n", 0, tl_tpg
->tl_tpgt
, se_lun
->unpacked_lun
);
898 * Remove Linux/SCSI struct scsi_device by HCTL
900 scsi_remove_device(sd
);
903 atomic_dec_mb(&tl_tpg
->tl_tpg_port_count
);
905 pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");
908 /* End items for tcm_loop_port_cit */
910 static ssize_t
tcm_loop_tpg_attrib_show_fabric_prot_type(
911 struct se_portal_group
*se_tpg
,
914 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
917 return sprintf(page
, "%d\n", tl_tpg
->tl_fabric_prot_type
);
920 static ssize_t
tcm_loop_tpg_attrib_store_fabric_prot_type(
921 struct se_portal_group
*se_tpg
,
925 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
928 int ret
= kstrtoul(page
, 0, &val
);
931 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret
);
934 if (val
!= 0 && val
!= 1 && val
!= 3) {
935 pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val
);
938 tl_tpg
->tl_fabric_prot_type
= val
;
943 TF_TPG_ATTRIB_ATTR(tcm_loop
, fabric_prot_type
, S_IRUGO
| S_IWUSR
);
945 static struct configfs_attribute
*tcm_loop_tpg_attrib_attrs
[] = {
946 &tcm_loop_tpg_attrib_fabric_prot_type
.attr
,
950 /* Start items for tcm_loop_nexus_cit */
952 static int tcm_loop_make_nexus(
953 struct tcm_loop_tpg
*tl_tpg
,
956 struct se_portal_group
*se_tpg
;
957 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
958 struct tcm_loop_nexus
*tl_nexus
;
961 if (tl_tpg
->tl_nexus
) {
962 pr_debug("tl_tpg->tl_nexus already exists\n");
965 se_tpg
= &tl_tpg
->tl_se_tpg
;
967 tl_nexus
= kzalloc(sizeof(struct tcm_loop_nexus
), GFP_KERNEL
);
969 pr_err("Unable to allocate struct tcm_loop_nexus\n");
973 * Initialize the struct se_session pointer
975 tl_nexus
->se_sess
= transport_init_session(
976 TARGET_PROT_DIN_PASS
| TARGET_PROT_DOUT_PASS
);
977 if (IS_ERR(tl_nexus
->se_sess
)) {
978 ret
= PTR_ERR(tl_nexus
->se_sess
);
982 * Since we are running in 'demo mode' this call with generate a
983 * struct se_node_acl for the tcm_loop struct se_portal_group with the SCSI
984 * Initiator port name of the passed configfs group 'name'.
986 tl_nexus
->se_sess
->se_node_acl
= core_tpg_check_initiator_node_acl(
987 se_tpg
, (unsigned char *)name
);
988 if (!tl_nexus
->se_sess
->se_node_acl
) {
989 transport_free_session(tl_nexus
->se_sess
);
992 /* Now, register the SAS I_T Nexus as active. */
993 transport_register_session(se_tpg
, tl_nexus
->se_sess
->se_node_acl
,
994 tl_nexus
->se_sess
, tl_nexus
);
995 tl_tpg
->tl_nexus
= tl_nexus
;
996 pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated"
997 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba
),
1006 static int tcm_loop_drop_nexus(
1007 struct tcm_loop_tpg
*tpg
)
1009 struct se_session
*se_sess
;
1010 struct tcm_loop_nexus
*tl_nexus
;
1012 tl_nexus
= tpg
->tl_nexus
;
1016 se_sess
= tl_nexus
->se_sess
;
1020 if (atomic_read(&tpg
->tl_tpg_port_count
)) {
1021 pr_err("Unable to remove TCM_Loop I_T Nexus with"
1022 " active TPG port count: %d\n",
1023 atomic_read(&tpg
->tl_tpg_port_count
));
1027 pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated"
1028 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tpg
->tl_hba
),
1029 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
1031 * Release the SCSI I_T Nexus to the emulated SAS Target Port
1033 transport_deregister_session(tl_nexus
->se_sess
);
1034 tpg
->tl_nexus
= NULL
;
1039 /* End items for tcm_loop_nexus_cit */
1041 static ssize_t
tcm_loop_tpg_show_nexus(
1042 struct se_portal_group
*se_tpg
,
1045 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1046 struct tcm_loop_tpg
, tl_se_tpg
);
1047 struct tcm_loop_nexus
*tl_nexus
;
1050 tl_nexus
= tl_tpg
->tl_nexus
;
1054 ret
= snprintf(page
, PAGE_SIZE
, "%s\n",
1055 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
1060 static ssize_t
tcm_loop_tpg_store_nexus(
1061 struct se_portal_group
*se_tpg
,
1065 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1066 struct tcm_loop_tpg
, tl_se_tpg
);
1067 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
1068 unsigned char i_port
[TL_WWN_ADDR_LEN
], *ptr
, *port_ptr
;
1071 * Shutdown the active I_T nexus if 'NULL' is passed..
1073 if (!strncmp(page
, "NULL", 4)) {
1074 ret
= tcm_loop_drop_nexus(tl_tpg
);
1075 return (!ret
) ? count
: ret
;
1078 * Otherwise make sure the passed virtual Initiator port WWN matches
1079 * the fabric protocol_id set in tcm_loop_make_scsi_hba(), and call
1080 * tcm_loop_make_nexus()
1082 if (strlen(page
) >= TL_WWN_ADDR_LEN
) {
1083 pr_err("Emulated NAA Sas Address: %s, exceeds"
1084 " max: %d\n", page
, TL_WWN_ADDR_LEN
);
1087 snprintf(&i_port
[0], TL_WWN_ADDR_LEN
, "%s", page
);
1089 ptr
= strstr(i_port
, "naa.");
1091 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_SAS
) {
1092 pr_err("Passed SAS Initiator Port %s does not"
1093 " match target port protoid: %s\n", i_port
,
1094 tcm_loop_dump_proto_id(tl_hba
));
1097 port_ptr
= &i_port
[0];
1100 ptr
= strstr(i_port
, "fc.");
1102 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_FCP
) {
1103 pr_err("Passed FCP Initiator Port %s does not"
1104 " match target port protoid: %s\n", i_port
,
1105 tcm_loop_dump_proto_id(tl_hba
));
1108 port_ptr
= &i_port
[3]; /* Skip over "fc." */
1111 ptr
= strstr(i_port
, "iqn.");
1113 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_ISCSI
) {
1114 pr_err("Passed iSCSI Initiator Port %s does not"
1115 " match target port protoid: %s\n", i_port
,
1116 tcm_loop_dump_proto_id(tl_hba
));
1119 port_ptr
= &i_port
[0];
1122 pr_err("Unable to locate prefix for emulated Initiator Port:"
1126 * Clear any trailing newline for the NAA WWN
1129 if (i_port
[strlen(i_port
)-1] == '\n')
1130 i_port
[strlen(i_port
)-1] = '\0';
1132 ret
= tcm_loop_make_nexus(tl_tpg
, port_ptr
);
1139 TF_TPG_BASE_ATTR(tcm_loop
, nexus
, S_IRUGO
| S_IWUSR
);
1141 static ssize_t
tcm_loop_tpg_show_transport_status(
1142 struct se_portal_group
*se_tpg
,
1145 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1146 struct tcm_loop_tpg
, tl_se_tpg
);
1147 const char *status
= NULL
;
1148 ssize_t ret
= -EINVAL
;
1150 switch (tl_tpg
->tl_transport_status
) {
1151 case TCM_TRANSPORT_ONLINE
:
1154 case TCM_TRANSPORT_OFFLINE
:
1162 ret
= snprintf(page
, PAGE_SIZE
, "%s\n", status
);
1167 static ssize_t
tcm_loop_tpg_store_transport_status(
1168 struct se_portal_group
*se_tpg
,
1172 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1173 struct tcm_loop_tpg
, tl_se_tpg
);
1175 if (!strncmp(page
, "online", 6)) {
1176 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_ONLINE
;
1179 if (!strncmp(page
, "offline", 7)) {
1180 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_OFFLINE
;
1186 TF_TPG_BASE_ATTR(tcm_loop
, transport_status
, S_IRUGO
| S_IWUSR
);
1188 static struct configfs_attribute
*tcm_loop_tpg_attrs
[] = {
1189 &tcm_loop_tpg_nexus
.attr
,
1190 &tcm_loop_tpg_transport_status
.attr
,
1194 /* Start items for tcm_loop_naa_cit */
1196 static struct se_portal_group
*tcm_loop_make_naa_tpg(
1198 struct config_group
*group
,
1201 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1202 struct tcm_loop_hba
, tl_hba_wwn
);
1203 struct tcm_loop_tpg
*tl_tpg
;
1207 if (strstr(name
, "tpgt_") != name
) {
1208 pr_err("Unable to locate \"tpgt_#\" directory"
1210 return ERR_PTR(-EINVAL
);
1212 if (kstrtoul(name
+5, 10, &tpgt
))
1213 return ERR_PTR(-EINVAL
);
1215 if (tpgt
>= TL_TPGS_PER_HBA
) {
1216 pr_err("Passed tpgt: %lu exceeds TL_TPGS_PER_HBA:"
1217 " %u\n", tpgt
, TL_TPGS_PER_HBA
);
1218 return ERR_PTR(-EINVAL
);
1220 tl_tpg
= &tl_hba
->tl_hba_tpgs
[tpgt
];
1221 tl_tpg
->tl_hba
= tl_hba
;
1222 tl_tpg
->tl_tpgt
= tpgt
;
1224 * Register the tl_tpg as a emulated SAS TCM Target Endpoint
1226 ret
= core_tpg_register(&loop_ops
, wwn
, &tl_tpg
->tl_se_tpg
, tl_tpg
,
1227 TRANSPORT_TPG_TYPE_NORMAL
);
1229 return ERR_PTR(-ENOMEM
);
1231 pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s"
1232 " Target Port %s,t,0x%04lx\n", tcm_loop_dump_proto_id(tl_hba
),
1233 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1235 return &tl_tpg
->tl_se_tpg
;
1238 static void tcm_loop_drop_naa_tpg(
1239 struct se_portal_group
*se_tpg
)
1241 struct se_wwn
*wwn
= se_tpg
->se_tpg_wwn
;
1242 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1243 struct tcm_loop_tpg
, tl_se_tpg
);
1244 struct tcm_loop_hba
*tl_hba
;
1245 unsigned short tpgt
;
1247 tl_hba
= tl_tpg
->tl_hba
;
1248 tpgt
= tl_tpg
->tl_tpgt
;
1250 * Release the I_T Nexus for the Virtual SAS link if present
1252 tcm_loop_drop_nexus(tl_tpg
);
1254 * Deregister the tl_tpg as a emulated SAS TCM Target Endpoint
1256 core_tpg_deregister(se_tpg
);
1258 tl_tpg
->tl_hba
= NULL
;
1259 tl_tpg
->tl_tpgt
= 0;
1261 pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s"
1262 " Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba
),
1263 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1266 /* End items for tcm_loop_naa_cit */
1268 /* Start items for tcm_loop_cit */
1270 static struct se_wwn
*tcm_loop_make_scsi_hba(
1271 struct target_fabric_configfs
*tf
,
1272 struct config_group
*group
,
1275 struct tcm_loop_hba
*tl_hba
;
1276 struct Scsi_Host
*sh
;
1280 tl_hba
= kzalloc(sizeof(struct tcm_loop_hba
), GFP_KERNEL
);
1282 pr_err("Unable to allocate struct tcm_loop_hba\n");
1283 return ERR_PTR(-ENOMEM
);
1286 * Determine the emulated Protocol Identifier and Target Port Name
1287 * based on the incoming configfs directory name.
1289 ptr
= strstr(name
, "naa.");
1291 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_SAS
;
1294 ptr
= strstr(name
, "fc.");
1296 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_FCP
;
1297 off
= 3; /* Skip over "fc." */
1300 ptr
= strstr(name
, "iqn.");
1302 pr_err("Unable to locate prefix for emulated Target "
1303 "Port: %s\n", name
);
1307 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_ISCSI
;
1310 if (strlen(name
) >= TL_WWN_ADDR_LEN
) {
1311 pr_err("Emulated NAA %s Address: %s, exceeds"
1312 " max: %d\n", name
, tcm_loop_dump_proto_id(tl_hba
),
1317 snprintf(&tl_hba
->tl_wwn_address
[0], TL_WWN_ADDR_LEN
, "%s", &name
[off
]);
1320 * Call device_register(tl_hba->dev) to register the emulated
1321 * Linux/SCSI LLD of type struct Scsi_Host at tl_hba->sh after
1322 * device_register() callbacks in tcm_loop_driver_probe()
1324 ret
= tcm_loop_setup_hba_bus(tl_hba
, tcm_loop_hba_no_cnt
);
1329 tcm_loop_hba_no_cnt
++;
1330 pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target"
1331 " %s Address: %s at Linux/SCSI Host ID: %d\n",
1332 tcm_loop_dump_proto_id(tl_hba
), name
, sh
->host_no
);
1334 return &tl_hba
->tl_hba_wwn
;
1337 return ERR_PTR(ret
);
1340 static void tcm_loop_drop_scsi_hba(
1343 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1344 struct tcm_loop_hba
, tl_hba_wwn
);
1346 pr_debug("TCM_Loop_ConfigFS: Deallocating emulated Target"
1347 " SAS Address: %s at Linux/SCSI Host ID: %d\n",
1348 tl_hba
->tl_wwn_address
, tl_hba
->sh
->host_no
);
1350 * Call device_unregister() on the original tl_hba->dev.
1351 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will
1354 device_unregister(&tl_hba
->dev
);
1357 /* Start items for tcm_loop_cit */
1358 static ssize_t
tcm_loop_wwn_show_attr_version(
1359 struct target_fabric_configfs
*tf
,
1362 return sprintf(page
, "TCM Loopback Fabric module %s\n", TCM_LOOP_VERSION
);
1365 TF_WWN_ATTR_RO(tcm_loop
, version
);
1367 static struct configfs_attribute
*tcm_loop_wwn_attrs
[] = {
1368 &tcm_loop_wwn_version
.attr
,
1372 /* End items for tcm_loop_cit */
1374 static const struct target_core_fabric_ops loop_ops
= {
1375 .module
= THIS_MODULE
,
1377 .get_fabric_name
= tcm_loop_get_fabric_name
,
1378 .get_fabric_proto_ident
= tcm_loop_get_fabric_proto_ident
,
1379 .tpg_get_wwn
= tcm_loop_get_endpoint_wwn
,
1380 .tpg_get_tag
= tcm_loop_get_tag
,
1381 .tpg_get_default_depth
= tcm_loop_get_default_depth
,
1382 .tpg_get_pr_transport_id
= tcm_loop_get_pr_transport_id
,
1383 .tpg_get_pr_transport_id_len
= tcm_loop_get_pr_transport_id_len
,
1384 .tpg_parse_pr_out_transport_id
= tcm_loop_parse_pr_out_transport_id
,
1385 .tpg_check_demo_mode
= tcm_loop_check_demo_mode
,
1386 .tpg_check_demo_mode_cache
= tcm_loop_check_demo_mode_cache
,
1387 .tpg_check_demo_mode_write_protect
=
1388 tcm_loop_check_demo_mode_write_protect
,
1389 .tpg_check_prod_mode_write_protect
=
1390 tcm_loop_check_prod_mode_write_protect
,
1391 .tpg_check_prot_fabric_only
= tcm_loop_check_prot_fabric_only
,
1392 .tpg_alloc_fabric_acl
= tcm_loop_tpg_alloc_fabric_acl
,
1393 .tpg_release_fabric_acl
= tcm_loop_tpg_release_fabric_acl
,
1394 .tpg_get_inst_index
= tcm_loop_get_inst_index
,
1395 .check_stop_free
= tcm_loop_check_stop_free
,
1396 .release_cmd
= tcm_loop_release_cmd
,
1397 .shutdown_session
= tcm_loop_shutdown_session
,
1398 .close_session
= tcm_loop_close_session
,
1399 .sess_get_index
= tcm_loop_sess_get_index
,
1400 .write_pending
= tcm_loop_write_pending
,
1401 .write_pending_status
= tcm_loop_write_pending_status
,
1402 .set_default_node_attributes
= tcm_loop_set_default_node_attributes
,
1403 .get_task_tag
= tcm_loop_get_task_tag
,
1404 .get_cmd_state
= tcm_loop_get_cmd_state
,
1405 .queue_data_in
= tcm_loop_queue_data_in
,
1406 .queue_status
= tcm_loop_queue_status
,
1407 .queue_tm_rsp
= tcm_loop_queue_tm_rsp
,
1408 .aborted_task
= tcm_loop_aborted_task
,
1409 .fabric_make_wwn
= tcm_loop_make_scsi_hba
,
1410 .fabric_drop_wwn
= tcm_loop_drop_scsi_hba
,
1411 .fabric_make_tpg
= tcm_loop_make_naa_tpg
,
1412 .fabric_drop_tpg
= tcm_loop_drop_naa_tpg
,
1413 .fabric_post_link
= tcm_loop_port_link
,
1414 .fabric_pre_unlink
= tcm_loop_port_unlink
,
1415 .tfc_wwn_attrs
= tcm_loop_wwn_attrs
,
1416 .tfc_tpg_base_attrs
= tcm_loop_tpg_attrs
,
1417 .tfc_tpg_attrib_attrs
= tcm_loop_tpg_attrib_attrs
,
1420 static int __init
tcm_loop_fabric_init(void)
1424 tcm_loop_workqueue
= alloc_workqueue("tcm_loop", 0, 0);
1425 if (!tcm_loop_workqueue
)
1428 tcm_loop_cmd_cache
= kmem_cache_create("tcm_loop_cmd_cache",
1429 sizeof(struct tcm_loop_cmd
),
1430 __alignof__(struct tcm_loop_cmd
),
1432 if (!tcm_loop_cmd_cache
) {
1433 pr_debug("kmem_cache_create() for"
1434 " tcm_loop_cmd_cache failed\n");
1435 goto out_destroy_workqueue
;
1438 ret
= tcm_loop_alloc_core_bus();
1440 goto out_destroy_cache
;
1442 ret
= target_register_template(&loop_ops
);
1444 goto out_release_core_bus
;
1448 out_release_core_bus
:
1449 tcm_loop_release_core_bus();
1451 kmem_cache_destroy(tcm_loop_cmd_cache
);
1452 out_destroy_workqueue
:
1453 destroy_workqueue(tcm_loop_workqueue
);
1458 static void __exit
tcm_loop_fabric_exit(void)
1460 target_unregister_template(&loop_ops
);
1461 tcm_loop_release_core_bus();
1462 kmem_cache_destroy(tcm_loop_cmd_cache
);
1463 destroy_workqueue(tcm_loop_workqueue
);
1466 MODULE_DESCRIPTION("TCM loopback virtual Linux/SCSI fabric module");
1467 MODULE_AUTHOR("Nicholas A. Bellinger <nab@risingtidesystems.com>");
1468 MODULE_LICENSE("GPL");
1469 module_init(tcm_loop_fabric_init
);
1470 module_exit(tcm_loop_fabric_exit
);