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>
41 #define to_tcm_loop_hba(hba) container_of(hba, struct tcm_loop_hba, dev)
43 static struct workqueue_struct
*tcm_loop_workqueue
;
44 static struct kmem_cache
*tcm_loop_cmd_cache
;
46 static int tcm_loop_hba_no_cnt
;
48 static int tcm_loop_queue_status(struct se_cmd
*se_cmd
);
51 * Called from struct target_core_fabric_ops->check_stop_free()
53 static int tcm_loop_check_stop_free(struct se_cmd
*se_cmd
)
56 * Do not release struct se_cmd's containing a valid TMR
57 * pointer. These will be released directly in tcm_loop_device_reset()
58 * with transport_generic_free_cmd().
60 if (se_cmd
->se_cmd_flags
& SCF_SCSI_TMR_CDB
)
63 * Release the struct se_cmd, which will make a callback to release
64 * struct tcm_loop_cmd * in tcm_loop_deallocate_core_cmd()
66 transport_generic_free_cmd(se_cmd
, 0);
70 static void tcm_loop_release_cmd(struct se_cmd
*se_cmd
)
72 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
73 struct tcm_loop_cmd
, tl_se_cmd
);
75 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
78 static int tcm_loop_show_info(struct seq_file
*m
, struct Scsi_Host
*host
)
80 seq_printf(m
, "tcm_loop_proc_info()\n");
84 static int tcm_loop_driver_probe(struct device
*);
85 static int tcm_loop_driver_remove(struct device
*);
87 static int pseudo_lld_bus_match(struct device
*dev
,
88 struct device_driver
*dev_driver
)
93 static struct bus_type tcm_loop_lld_bus
= {
94 .name
= "tcm_loop_bus",
95 .match
= pseudo_lld_bus_match
,
96 .probe
= tcm_loop_driver_probe
,
97 .remove
= tcm_loop_driver_remove
,
100 static struct device_driver tcm_loop_driverfs
= {
102 .bus
= &tcm_loop_lld_bus
,
105 * Used with root_device_register() in tcm_loop_alloc_core_bus() below
107 static struct device
*tcm_loop_primary
;
109 static void tcm_loop_submission_work(struct work_struct
*work
)
111 struct tcm_loop_cmd
*tl_cmd
=
112 container_of(work
, struct tcm_loop_cmd
, work
);
113 struct se_cmd
*se_cmd
= &tl_cmd
->tl_se_cmd
;
114 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
115 struct tcm_loop_nexus
*tl_nexus
;
116 struct tcm_loop_hba
*tl_hba
;
117 struct tcm_loop_tpg
*tl_tpg
;
118 struct scatterlist
*sgl_bidi
= NULL
;
119 u32 sgl_bidi_count
= 0, transfer_length
;
122 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
123 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
126 * Ensure that this tl_tpg reference from the incoming sc->device->id
127 * has already been configured via tcm_loop_make_naa_tpg().
129 if (!tl_tpg
->tl_hba
) {
130 set_host_byte(sc
, DID_NO_CONNECT
);
133 if (tl_tpg
->tl_transport_status
== TCM_TRANSPORT_OFFLINE
) {
134 set_host_byte(sc
, DID_TRANSPORT_DISRUPTED
);
137 tl_nexus
= tl_tpg
->tl_nexus
;
139 scmd_printk(KERN_ERR
, sc
, "TCM_Loop I_T Nexus"
140 " does not exist\n");
141 set_host_byte(sc
, DID_ERROR
);
144 if (scsi_bidi_cmnd(sc
)) {
145 struct scsi_data_buffer
*sdb
= scsi_in(sc
);
147 sgl_bidi
= sdb
->table
.sgl
;
148 sgl_bidi_count
= sdb
->table
.nents
;
149 se_cmd
->se_cmd_flags
|= SCF_BIDI
;
153 transfer_length
= scsi_transfer_length(sc
);
154 if (!scsi_prot_sg_count(sc
) &&
155 scsi_get_prot_op(sc
) != SCSI_PROT_NORMAL
) {
156 se_cmd
->prot_pto
= true;
158 * loopback transport doesn't support
159 * WRITE_GENERATE, READ_STRIP protection
160 * information operations, go ahead unprotected.
162 transfer_length
= scsi_bufflen(sc
);
165 se_cmd
->tag
= tl_cmd
->sc_cmd_tag
;
166 rc
= target_submit_cmd_map_sgls(se_cmd
, tl_nexus
->se_sess
, sc
->cmnd
,
167 &tl_cmd
->tl_sense_buf
[0], tl_cmd
->sc
->device
->lun
,
168 transfer_length
, TCM_SIMPLE_TAG
,
169 sc
->sc_data_direction
, 0,
170 scsi_sglist(sc
), scsi_sg_count(sc
),
171 sgl_bidi
, sgl_bidi_count
,
172 scsi_prot_sglist(sc
), scsi_prot_sg_count(sc
));
174 set_host_byte(sc
, DID_NO_CONNECT
);
180 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
186 * ->queuecommand can be and usually is called from interrupt context, so
187 * defer the actual submission to a workqueue.
189 static int tcm_loop_queuecommand(struct Scsi_Host
*sh
, struct scsi_cmnd
*sc
)
191 struct tcm_loop_cmd
*tl_cmd
;
193 pr_debug("tcm_loop_queuecommand() %d:%d:%d:%llu got CDB: 0x%02x"
194 " scsi_buf_len: %u\n", sc
->device
->host
->host_no
,
195 sc
->device
->id
, sc
->device
->channel
, sc
->device
->lun
,
196 sc
->cmnd
[0], scsi_bufflen(sc
));
198 tl_cmd
= kmem_cache_zalloc(tcm_loop_cmd_cache
, GFP_ATOMIC
);
200 pr_err("Unable to allocate struct tcm_loop_cmd\n");
201 set_host_byte(sc
, DID_ERROR
);
207 tl_cmd
->sc_cmd_tag
= sc
->request
->tag
;
208 INIT_WORK(&tl_cmd
->work
, tcm_loop_submission_work
);
209 queue_work(tcm_loop_workqueue
, &tl_cmd
->work
);
214 * Called from SCSI EH process context to issue a LUN_RESET TMR
215 * to struct scsi_device
217 static int tcm_loop_issue_tmr(struct tcm_loop_tpg
*tl_tpg
,
218 u64 lun
, int task
, enum tcm_tmreq_table tmr
)
220 struct se_cmd
*se_cmd
= NULL
;
221 struct se_session
*se_sess
;
222 struct se_portal_group
*se_tpg
;
223 struct tcm_loop_nexus
*tl_nexus
;
224 struct tcm_loop_cmd
*tl_cmd
= NULL
;
225 struct tcm_loop_tmr
*tl_tmr
= NULL
;
226 int ret
= TMR_FUNCTION_FAILED
, rc
;
229 * Locate the tl_nexus and se_sess pointers
231 tl_nexus
= tl_tpg
->tl_nexus
;
233 pr_err("Unable to perform device reset without"
234 " active I_T Nexus\n");
238 tl_cmd
= kmem_cache_zalloc(tcm_loop_cmd_cache
, GFP_KERNEL
);
240 pr_err("Unable to allocate memory for tl_cmd\n");
244 tl_tmr
= kzalloc(sizeof(struct tcm_loop_tmr
), GFP_KERNEL
);
246 pr_err("Unable to allocate memory for tl_tmr\n");
249 init_waitqueue_head(&tl_tmr
->tl_tmr_wait
);
251 se_cmd
= &tl_cmd
->tl_se_cmd
;
252 se_tpg
= &tl_tpg
->tl_se_tpg
;
253 se_sess
= tl_tpg
->tl_nexus
->se_sess
;
255 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
257 transport_init_se_cmd(se_cmd
, se_tpg
->se_tpg_tfo
, se_sess
, 0,
258 DMA_NONE
, TCM_SIMPLE_TAG
,
259 &tl_cmd
->tl_sense_buf
[0]);
261 rc
= core_tmr_alloc_req(se_cmd
, tl_tmr
, tmr
, GFP_KERNEL
);
265 if (tmr
== TMR_ABORT_TASK
)
266 se_cmd
->se_tmr_req
->ref_task_tag
= task
;
269 * Locate the underlying TCM struct se_lun
271 if (transport_lookup_tmr_lun(se_cmd
, lun
) < 0) {
272 ret
= TMR_LUN_DOES_NOT_EXIST
;
276 * Queue the TMR to TCM Core and sleep waiting for
277 * tcm_loop_queue_tm_rsp() to wake us up.
279 transport_generic_handle_tmr(se_cmd
);
280 wait_event(tl_tmr
->tl_tmr_wait
, atomic_read(&tl_tmr
->tmr_complete
));
282 * The TMR LUN_RESET has completed, check the response status and
283 * then release allocations.
285 ret
= se_cmd
->se_tmr_req
->response
;
288 transport_generic_free_cmd(se_cmd
, 1);
290 kmem_cache_free(tcm_loop_cmd_cache
, tl_cmd
);
295 static int tcm_loop_abort_task(struct scsi_cmnd
*sc
)
297 struct tcm_loop_hba
*tl_hba
;
298 struct tcm_loop_tpg
*tl_tpg
;
302 * Locate the tcm_loop_hba_t pointer
304 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
305 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
306 ret
= tcm_loop_issue_tmr(tl_tpg
, sc
->device
->lun
,
307 sc
->request
->tag
, TMR_ABORT_TASK
);
308 return (ret
== TMR_FUNCTION_COMPLETE
) ? SUCCESS
: FAILED
;
312 * Called from SCSI EH process context to issue a LUN_RESET TMR
313 * to struct scsi_device
315 static int tcm_loop_device_reset(struct scsi_cmnd
*sc
)
317 struct tcm_loop_hba
*tl_hba
;
318 struct tcm_loop_tpg
*tl_tpg
;
322 * Locate the tcm_loop_hba_t pointer
324 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
325 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
327 ret
= tcm_loop_issue_tmr(tl_tpg
, sc
->device
->lun
,
329 return (ret
== TMR_FUNCTION_COMPLETE
) ? SUCCESS
: FAILED
;
332 static int tcm_loop_target_reset(struct scsi_cmnd
*sc
)
334 struct tcm_loop_hba
*tl_hba
;
335 struct tcm_loop_tpg
*tl_tpg
;
338 * Locate the tcm_loop_hba_t pointer
340 tl_hba
= *(struct tcm_loop_hba
**)shost_priv(sc
->device
->host
);
342 pr_err("Unable to perform device reset without"
343 " active I_T Nexus\n");
347 * Locate the tl_tpg pointer from TargetID in sc->device->id
349 tl_tpg
= &tl_hba
->tl_hba_tpgs
[sc
->device
->id
];
351 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_ONLINE
;
357 static int tcm_loop_slave_alloc(struct scsi_device
*sd
)
359 set_bit(QUEUE_FLAG_BIDI
, &sd
->request_queue
->queue_flags
);
363 static struct scsi_host_template tcm_loop_driver_template
= {
364 .show_info
= tcm_loop_show_info
,
365 .proc_name
= "tcm_loopback",
366 .name
= "TCM_Loopback",
367 .queuecommand
= tcm_loop_queuecommand
,
368 .change_queue_depth
= scsi_change_queue_depth
,
369 .eh_abort_handler
= tcm_loop_abort_task
,
370 .eh_device_reset_handler
= tcm_loop_device_reset
,
371 .eh_target_reset_handler
= tcm_loop_target_reset
,
376 .max_sectors
= 0xFFFF,
377 .use_clustering
= DISABLE_CLUSTERING
,
378 .slave_alloc
= tcm_loop_slave_alloc
,
379 .module
= THIS_MODULE
,
380 .track_queue_depth
= 1,
383 static int tcm_loop_driver_probe(struct device
*dev
)
385 struct tcm_loop_hba
*tl_hba
;
386 struct Scsi_Host
*sh
;
387 int error
, host_prot
;
389 tl_hba
= to_tcm_loop_hba(dev
);
391 sh
= scsi_host_alloc(&tcm_loop_driver_template
,
392 sizeof(struct tcm_loop_hba
));
394 pr_err("Unable to allocate struct scsi_host\n");
400 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata
402 *((struct tcm_loop_hba
**)sh
->hostdata
) = tl_hba
;
404 * Setup single ID, Channel and LUN for now..
409 sh
->max_cmd_len
= SCSI_MAX_VARLEN_CDB_SIZE
;
411 host_prot
= SHOST_DIF_TYPE1_PROTECTION
| SHOST_DIF_TYPE2_PROTECTION
|
412 SHOST_DIF_TYPE3_PROTECTION
| SHOST_DIX_TYPE1_PROTECTION
|
413 SHOST_DIX_TYPE2_PROTECTION
| SHOST_DIX_TYPE3_PROTECTION
;
415 scsi_host_set_prot(sh
, host_prot
);
416 scsi_host_set_guard(sh
, SHOST_DIX_GUARD_CRC
);
418 error
= scsi_add_host(sh
, &tl_hba
->dev
);
420 pr_err("%s: scsi_add_host failed\n", __func__
);
427 static int tcm_loop_driver_remove(struct device
*dev
)
429 struct tcm_loop_hba
*tl_hba
;
430 struct Scsi_Host
*sh
;
432 tl_hba
= to_tcm_loop_hba(dev
);
435 scsi_remove_host(sh
);
440 static void tcm_loop_release_adapter(struct device
*dev
)
442 struct tcm_loop_hba
*tl_hba
= to_tcm_loop_hba(dev
);
448 * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c
450 static int tcm_loop_setup_hba_bus(struct tcm_loop_hba
*tl_hba
, int tcm_loop_host_id
)
454 tl_hba
->dev
.bus
= &tcm_loop_lld_bus
;
455 tl_hba
->dev
.parent
= tcm_loop_primary
;
456 tl_hba
->dev
.release
= &tcm_loop_release_adapter
;
457 dev_set_name(&tl_hba
->dev
, "tcm_loop_adapter_%d", tcm_loop_host_id
);
459 ret
= device_register(&tl_hba
->dev
);
461 pr_err("device_register() failed for"
462 " tl_hba->dev: %d\n", ret
);
470 * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated
473 static int tcm_loop_alloc_core_bus(void)
477 tcm_loop_primary
= root_device_register("tcm_loop_0");
478 if (IS_ERR(tcm_loop_primary
)) {
479 pr_err("Unable to allocate tcm_loop_primary\n");
480 return PTR_ERR(tcm_loop_primary
);
483 ret
= bus_register(&tcm_loop_lld_bus
);
485 pr_err("bus_register() failed for tcm_loop_lld_bus\n");
489 ret
= driver_register(&tcm_loop_driverfs
);
491 pr_err("driver_register() failed for"
492 "tcm_loop_driverfs\n");
496 pr_debug("Initialized TCM Loop Core Bus\n");
500 bus_unregister(&tcm_loop_lld_bus
);
502 root_device_unregister(tcm_loop_primary
);
506 static void tcm_loop_release_core_bus(void)
508 driver_unregister(&tcm_loop_driverfs
);
509 bus_unregister(&tcm_loop_lld_bus
);
510 root_device_unregister(tcm_loop_primary
);
512 pr_debug("Releasing TCM Loop Core BUS\n");
515 static char *tcm_loop_get_fabric_name(void)
520 static inline struct tcm_loop_tpg
*tl_tpg(struct se_portal_group
*se_tpg
)
522 return container_of(se_tpg
, struct tcm_loop_tpg
, tl_se_tpg
);
525 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group
*se_tpg
)
528 * Return the passed NAA identifier for the Target Port
530 return &tl_tpg(se_tpg
)->tl_hba
->tl_wwn_address
[0];
533 static u16
tcm_loop_get_tag(struct se_portal_group
*se_tpg
)
536 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83
537 * to represent the SCSI Target Port.
539 return tl_tpg(se_tpg
)->tl_tpgt
;
543 * Returning (1) here allows for target_core_mod struct se_node_acl to be generated
544 * based upon the incoming fabric dependent SCSI Initiator Port
546 static int tcm_loop_check_demo_mode(struct se_portal_group
*se_tpg
)
551 static int tcm_loop_check_demo_mode_cache(struct se_portal_group
*se_tpg
)
557 * Allow I_T Nexus full READ-WRITE access without explict Initiator Node ACLs for
558 * local virtual Linux/SCSI LLD passthrough into VM hypervisor guest
560 static int tcm_loop_check_demo_mode_write_protect(struct se_portal_group
*se_tpg
)
566 * Because TCM_Loop does not use explict ACLs and MappedLUNs, this will
567 * never be called for TCM_Loop by target_core_fabric_configfs.c code.
568 * It has been added here as a nop for target_fabric_tf_ops_check()
570 static int tcm_loop_check_prod_mode_write_protect(struct se_portal_group
*se_tpg
)
575 static int tcm_loop_check_prot_fabric_only(struct se_portal_group
*se_tpg
)
577 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
579 return tl_tpg
->tl_fabric_prot_type
;
582 static u32
tcm_loop_get_inst_index(struct se_portal_group
*se_tpg
)
587 static u32
tcm_loop_sess_get_index(struct se_session
*se_sess
)
592 static void tcm_loop_set_default_node_attributes(struct se_node_acl
*se_acl
)
597 static int tcm_loop_get_cmd_state(struct se_cmd
*se_cmd
)
599 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
600 struct tcm_loop_cmd
, tl_se_cmd
);
602 return tl_cmd
->sc_cmd_state
;
605 static int tcm_loop_shutdown_session(struct se_session
*se_sess
)
610 static void tcm_loop_close_session(struct se_session
*se_sess
)
615 static int tcm_loop_write_pending(struct se_cmd
*se_cmd
)
618 * Since Linux/SCSI has already sent down a struct scsi_cmnd
619 * sc->sc_data_direction of DMA_TO_DEVICE with struct scatterlist array
620 * memory, and memory has already been mapped to struct se_cmd->t_mem_list
621 * format with transport_generic_map_mem_to_cmd().
623 * We now tell TCM to add this WRITE CDB directly into the TCM storage
624 * object execution queue.
626 target_execute_cmd(se_cmd
);
630 static int tcm_loop_write_pending_status(struct se_cmd
*se_cmd
)
635 static int tcm_loop_queue_data_in(struct se_cmd
*se_cmd
)
637 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
638 struct tcm_loop_cmd
, tl_se_cmd
);
639 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
641 pr_debug("tcm_loop_queue_data_in() called for scsi_cmnd: %p"
642 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
644 sc
->result
= SAM_STAT_GOOD
;
645 set_host_byte(sc
, DID_OK
);
646 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
647 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
648 scsi_set_resid(sc
, se_cmd
->residual_count
);
653 static int tcm_loop_queue_status(struct se_cmd
*se_cmd
)
655 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
656 struct tcm_loop_cmd
, tl_se_cmd
);
657 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
659 pr_debug("tcm_loop_queue_status() called for scsi_cmnd: %p"
660 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
662 if (se_cmd
->sense_buffer
&&
663 ((se_cmd
->se_cmd_flags
& SCF_TRANSPORT_TASK_SENSE
) ||
664 (se_cmd
->se_cmd_flags
& SCF_EMULATED_TASK_SENSE
))) {
666 memcpy(sc
->sense_buffer
, se_cmd
->sense_buffer
,
667 SCSI_SENSE_BUFFERSIZE
);
668 sc
->result
= SAM_STAT_CHECK_CONDITION
;
669 set_driver_byte(sc
, DRIVER_SENSE
);
671 sc
->result
= se_cmd
->scsi_status
;
673 set_host_byte(sc
, DID_OK
);
674 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
675 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
676 scsi_set_resid(sc
, se_cmd
->residual_count
);
681 static void tcm_loop_queue_tm_rsp(struct se_cmd
*se_cmd
)
683 struct se_tmr_req
*se_tmr
= se_cmd
->se_tmr_req
;
684 struct tcm_loop_tmr
*tl_tmr
= se_tmr
->fabric_tmr_ptr
;
686 * The SCSI EH thread will be sleeping on se_tmr->tl_tmr_wait, go ahead
687 * and wake up the wait_queue_head_t in tcm_loop_device_reset()
689 atomic_set(&tl_tmr
->tmr_complete
, 1);
690 wake_up(&tl_tmr
->tl_tmr_wait
);
693 static void tcm_loop_aborted_task(struct se_cmd
*se_cmd
)
698 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba
*tl_hba
)
700 switch (tl_hba
->tl_proto_id
) {
701 case SCSI_PROTOCOL_SAS
:
703 case SCSI_PROTOCOL_FCP
:
705 case SCSI_PROTOCOL_ISCSI
:
714 /* Start items for tcm_loop_port_cit */
716 static int tcm_loop_port_link(
717 struct se_portal_group
*se_tpg
,
720 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
721 struct tcm_loop_tpg
, tl_se_tpg
);
722 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
724 atomic_inc_mb(&tl_tpg
->tl_tpg_port_count
);
726 * Add Linux/SCSI struct scsi_device by HCTL
728 scsi_add_device(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
, lun
->unpacked_lun
);
730 pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n");
734 static void tcm_loop_port_unlink(
735 struct se_portal_group
*se_tpg
,
736 struct se_lun
*se_lun
)
738 struct scsi_device
*sd
;
739 struct tcm_loop_hba
*tl_hba
;
740 struct tcm_loop_tpg
*tl_tpg
;
742 tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
, tl_se_tpg
);
743 tl_hba
= tl_tpg
->tl_hba
;
745 sd
= scsi_device_lookup(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
,
746 se_lun
->unpacked_lun
);
748 pr_err("Unable to locate struct scsi_device for %d:%d:"
749 "%llu\n", 0, tl_tpg
->tl_tpgt
, se_lun
->unpacked_lun
);
753 * Remove Linux/SCSI struct scsi_device by HCTL
755 scsi_remove_device(sd
);
758 atomic_dec_mb(&tl_tpg
->tl_tpg_port_count
);
760 pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");
763 /* End items for tcm_loop_port_cit */
765 static ssize_t
tcm_loop_tpg_attrib_show_fabric_prot_type(
766 struct se_portal_group
*se_tpg
,
769 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
772 return sprintf(page
, "%d\n", tl_tpg
->tl_fabric_prot_type
);
775 static ssize_t
tcm_loop_tpg_attrib_store_fabric_prot_type(
776 struct se_portal_group
*se_tpg
,
780 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
783 int ret
= kstrtoul(page
, 0, &val
);
786 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret
);
789 if (val
!= 0 && val
!= 1 && val
!= 3) {
790 pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val
);
793 tl_tpg
->tl_fabric_prot_type
= val
;
798 TF_TPG_ATTRIB_ATTR(tcm_loop
, fabric_prot_type
, S_IRUGO
| S_IWUSR
);
800 static struct configfs_attribute
*tcm_loop_tpg_attrib_attrs
[] = {
801 &tcm_loop_tpg_attrib_fabric_prot_type
.attr
,
805 /* Start items for tcm_loop_nexus_cit */
807 static int tcm_loop_make_nexus(
808 struct tcm_loop_tpg
*tl_tpg
,
811 struct se_portal_group
*se_tpg
;
812 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
813 struct tcm_loop_nexus
*tl_nexus
;
816 if (tl_tpg
->tl_nexus
) {
817 pr_debug("tl_tpg->tl_nexus already exists\n");
820 se_tpg
= &tl_tpg
->tl_se_tpg
;
822 tl_nexus
= kzalloc(sizeof(struct tcm_loop_nexus
), GFP_KERNEL
);
824 pr_err("Unable to allocate struct tcm_loop_nexus\n");
828 * Initialize the struct se_session pointer
830 tl_nexus
->se_sess
= transport_init_session(
831 TARGET_PROT_DIN_PASS
| TARGET_PROT_DOUT_PASS
);
832 if (IS_ERR(tl_nexus
->se_sess
)) {
833 ret
= PTR_ERR(tl_nexus
->se_sess
);
837 * Since we are running in 'demo mode' this call with generate a
838 * struct se_node_acl for the tcm_loop struct se_portal_group with the SCSI
839 * Initiator port name of the passed configfs group 'name'.
841 tl_nexus
->se_sess
->se_node_acl
= core_tpg_check_initiator_node_acl(
842 se_tpg
, (unsigned char *)name
);
843 if (!tl_nexus
->se_sess
->se_node_acl
) {
844 transport_free_session(tl_nexus
->se_sess
);
847 /* Now, register the I_T Nexus as active. */
848 transport_register_session(se_tpg
, tl_nexus
->se_sess
->se_node_acl
,
849 tl_nexus
->se_sess
, tl_nexus
);
850 tl_tpg
->tl_nexus
= tl_nexus
;
851 pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated"
852 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba
),
861 static int tcm_loop_drop_nexus(
862 struct tcm_loop_tpg
*tpg
)
864 struct se_session
*se_sess
;
865 struct tcm_loop_nexus
*tl_nexus
;
867 tl_nexus
= tpg
->tl_nexus
;
871 se_sess
= tl_nexus
->se_sess
;
875 if (atomic_read(&tpg
->tl_tpg_port_count
)) {
876 pr_err("Unable to remove TCM_Loop I_T Nexus with"
877 " active TPG port count: %d\n",
878 atomic_read(&tpg
->tl_tpg_port_count
));
882 pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated"
883 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tpg
->tl_hba
),
884 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
886 * Release the SCSI I_T Nexus to the emulated Target Port
888 transport_deregister_session(tl_nexus
->se_sess
);
889 tpg
->tl_nexus
= NULL
;
894 /* End items for tcm_loop_nexus_cit */
896 static ssize_t
tcm_loop_tpg_show_nexus(
897 struct se_portal_group
*se_tpg
,
900 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
901 struct tcm_loop_tpg
, tl_se_tpg
);
902 struct tcm_loop_nexus
*tl_nexus
;
905 tl_nexus
= tl_tpg
->tl_nexus
;
909 ret
= snprintf(page
, PAGE_SIZE
, "%s\n",
910 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
915 static ssize_t
tcm_loop_tpg_store_nexus(
916 struct se_portal_group
*se_tpg
,
920 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
921 struct tcm_loop_tpg
, tl_se_tpg
);
922 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
923 unsigned char i_port
[TL_WWN_ADDR_LEN
], *ptr
, *port_ptr
;
926 * Shutdown the active I_T nexus if 'NULL' is passed..
928 if (!strncmp(page
, "NULL", 4)) {
929 ret
= tcm_loop_drop_nexus(tl_tpg
);
930 return (!ret
) ? count
: ret
;
933 * Otherwise make sure the passed virtual Initiator port WWN matches
934 * the fabric protocol_id set in tcm_loop_make_scsi_hba(), and call
935 * tcm_loop_make_nexus()
937 if (strlen(page
) >= TL_WWN_ADDR_LEN
) {
938 pr_err("Emulated NAA Sas Address: %s, exceeds"
939 " max: %d\n", page
, TL_WWN_ADDR_LEN
);
942 snprintf(&i_port
[0], TL_WWN_ADDR_LEN
, "%s", page
);
944 ptr
= strstr(i_port
, "naa.");
946 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_SAS
) {
947 pr_err("Passed SAS Initiator Port %s does not"
948 " match target port protoid: %s\n", i_port
,
949 tcm_loop_dump_proto_id(tl_hba
));
952 port_ptr
= &i_port
[0];
955 ptr
= strstr(i_port
, "fc.");
957 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_FCP
) {
958 pr_err("Passed FCP Initiator Port %s does not"
959 " match target port protoid: %s\n", i_port
,
960 tcm_loop_dump_proto_id(tl_hba
));
963 port_ptr
= &i_port
[3]; /* Skip over "fc." */
966 ptr
= strstr(i_port
, "iqn.");
968 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_ISCSI
) {
969 pr_err("Passed iSCSI Initiator Port %s does not"
970 " match target port protoid: %s\n", i_port
,
971 tcm_loop_dump_proto_id(tl_hba
));
974 port_ptr
= &i_port
[0];
977 pr_err("Unable to locate prefix for emulated Initiator Port:"
981 * Clear any trailing newline for the NAA WWN
984 if (i_port
[strlen(i_port
)-1] == '\n')
985 i_port
[strlen(i_port
)-1] = '\0';
987 ret
= tcm_loop_make_nexus(tl_tpg
, port_ptr
);
994 TF_TPG_BASE_ATTR(tcm_loop
, nexus
, S_IRUGO
| S_IWUSR
);
996 static ssize_t
tcm_loop_tpg_show_transport_status(
997 struct se_portal_group
*se_tpg
,
1000 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1001 struct tcm_loop_tpg
, tl_se_tpg
);
1002 const char *status
= NULL
;
1003 ssize_t ret
= -EINVAL
;
1005 switch (tl_tpg
->tl_transport_status
) {
1006 case TCM_TRANSPORT_ONLINE
:
1009 case TCM_TRANSPORT_OFFLINE
:
1017 ret
= snprintf(page
, PAGE_SIZE
, "%s\n", status
);
1022 static ssize_t
tcm_loop_tpg_store_transport_status(
1023 struct se_portal_group
*se_tpg
,
1027 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1028 struct tcm_loop_tpg
, tl_se_tpg
);
1030 if (!strncmp(page
, "online", 6)) {
1031 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_ONLINE
;
1034 if (!strncmp(page
, "offline", 7)) {
1035 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_OFFLINE
;
1036 if (tl_tpg
->tl_nexus
) {
1037 struct se_session
*tl_sess
= tl_tpg
->tl_nexus
->se_sess
;
1039 core_allocate_nexus_loss_ua(tl_sess
->se_node_acl
);
1046 TF_TPG_BASE_ATTR(tcm_loop
, transport_status
, S_IRUGO
| S_IWUSR
);
1048 static struct configfs_attribute
*tcm_loop_tpg_attrs
[] = {
1049 &tcm_loop_tpg_nexus
.attr
,
1050 &tcm_loop_tpg_transport_status
.attr
,
1054 /* Start items for tcm_loop_naa_cit */
1056 static struct se_portal_group
*tcm_loop_make_naa_tpg(
1058 struct config_group
*group
,
1061 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1062 struct tcm_loop_hba
, tl_hba_wwn
);
1063 struct tcm_loop_tpg
*tl_tpg
;
1067 if (strstr(name
, "tpgt_") != name
) {
1068 pr_err("Unable to locate \"tpgt_#\" directory"
1070 return ERR_PTR(-EINVAL
);
1072 if (kstrtoul(name
+5, 10, &tpgt
))
1073 return ERR_PTR(-EINVAL
);
1075 if (tpgt
>= TL_TPGS_PER_HBA
) {
1076 pr_err("Passed tpgt: %lu exceeds TL_TPGS_PER_HBA:"
1077 " %u\n", tpgt
, TL_TPGS_PER_HBA
);
1078 return ERR_PTR(-EINVAL
);
1080 tl_tpg
= &tl_hba
->tl_hba_tpgs
[tpgt
];
1081 tl_tpg
->tl_hba
= tl_hba
;
1082 tl_tpg
->tl_tpgt
= tpgt
;
1084 * Register the tl_tpg as a emulated TCM Target Endpoint
1086 ret
= core_tpg_register(wwn
, &tl_tpg
->tl_se_tpg
, tl_hba
->tl_proto_id
);
1088 return ERR_PTR(-ENOMEM
);
1090 pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s"
1091 " Target Port %s,t,0x%04lx\n", tcm_loop_dump_proto_id(tl_hba
),
1092 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1094 return &tl_tpg
->tl_se_tpg
;
1097 static void tcm_loop_drop_naa_tpg(
1098 struct se_portal_group
*se_tpg
)
1100 struct se_wwn
*wwn
= se_tpg
->se_tpg_wwn
;
1101 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1102 struct tcm_loop_tpg
, tl_se_tpg
);
1103 struct tcm_loop_hba
*tl_hba
;
1104 unsigned short tpgt
;
1106 tl_hba
= tl_tpg
->tl_hba
;
1107 tpgt
= tl_tpg
->tl_tpgt
;
1109 * Release the I_T Nexus for the Virtual target link if present
1111 tcm_loop_drop_nexus(tl_tpg
);
1113 * Deregister the tl_tpg as a emulated TCM Target Endpoint
1115 core_tpg_deregister(se_tpg
);
1117 tl_tpg
->tl_hba
= NULL
;
1118 tl_tpg
->tl_tpgt
= 0;
1120 pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s"
1121 " Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba
),
1122 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1125 /* End items for tcm_loop_naa_cit */
1127 /* Start items for tcm_loop_cit */
1129 static struct se_wwn
*tcm_loop_make_scsi_hba(
1130 struct target_fabric_configfs
*tf
,
1131 struct config_group
*group
,
1134 struct tcm_loop_hba
*tl_hba
;
1135 struct Scsi_Host
*sh
;
1139 tl_hba
= kzalloc(sizeof(struct tcm_loop_hba
), GFP_KERNEL
);
1141 pr_err("Unable to allocate struct tcm_loop_hba\n");
1142 return ERR_PTR(-ENOMEM
);
1145 * Determine the emulated Protocol Identifier and Target Port Name
1146 * based on the incoming configfs directory name.
1148 ptr
= strstr(name
, "naa.");
1150 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_SAS
;
1153 ptr
= strstr(name
, "fc.");
1155 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_FCP
;
1156 off
= 3; /* Skip over "fc." */
1159 ptr
= strstr(name
, "iqn.");
1161 pr_err("Unable to locate prefix for emulated Target "
1162 "Port: %s\n", name
);
1166 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_ISCSI
;
1169 if (strlen(name
) >= TL_WWN_ADDR_LEN
) {
1170 pr_err("Emulated NAA %s Address: %s, exceeds"
1171 " max: %d\n", name
, tcm_loop_dump_proto_id(tl_hba
),
1176 snprintf(&tl_hba
->tl_wwn_address
[0], TL_WWN_ADDR_LEN
, "%s", &name
[off
]);
1179 * Call device_register(tl_hba->dev) to register the emulated
1180 * Linux/SCSI LLD of type struct Scsi_Host at tl_hba->sh after
1181 * device_register() callbacks in tcm_loop_driver_probe()
1183 ret
= tcm_loop_setup_hba_bus(tl_hba
, tcm_loop_hba_no_cnt
);
1188 tcm_loop_hba_no_cnt
++;
1189 pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target"
1190 " %s Address: %s at Linux/SCSI Host ID: %d\n",
1191 tcm_loop_dump_proto_id(tl_hba
), name
, sh
->host_no
);
1193 return &tl_hba
->tl_hba_wwn
;
1196 return ERR_PTR(ret
);
1199 static void tcm_loop_drop_scsi_hba(
1202 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1203 struct tcm_loop_hba
, tl_hba_wwn
);
1205 pr_debug("TCM_Loop_ConfigFS: Deallocating emulated Target"
1206 " %s Address: %s at Linux/SCSI Host ID: %d\n",
1207 tcm_loop_dump_proto_id(tl_hba
), tl_hba
->tl_wwn_address
,
1208 tl_hba
->sh
->host_no
);
1210 * Call device_unregister() on the original tl_hba->dev.
1211 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will
1214 device_unregister(&tl_hba
->dev
);
1217 /* Start items for tcm_loop_cit */
1218 static ssize_t
tcm_loop_wwn_show_attr_version(
1219 struct target_fabric_configfs
*tf
,
1222 return sprintf(page
, "TCM Loopback Fabric module %s\n", TCM_LOOP_VERSION
);
1225 TF_WWN_ATTR_RO(tcm_loop
, version
);
1227 static struct configfs_attribute
*tcm_loop_wwn_attrs
[] = {
1228 &tcm_loop_wwn_version
.attr
,
1232 /* End items for tcm_loop_cit */
1234 static const struct target_core_fabric_ops loop_ops
= {
1235 .module
= THIS_MODULE
,
1237 .get_fabric_name
= tcm_loop_get_fabric_name
,
1238 .tpg_get_wwn
= tcm_loop_get_endpoint_wwn
,
1239 .tpg_get_tag
= tcm_loop_get_tag
,
1240 .tpg_check_demo_mode
= tcm_loop_check_demo_mode
,
1241 .tpg_check_demo_mode_cache
= tcm_loop_check_demo_mode_cache
,
1242 .tpg_check_demo_mode_write_protect
=
1243 tcm_loop_check_demo_mode_write_protect
,
1244 .tpg_check_prod_mode_write_protect
=
1245 tcm_loop_check_prod_mode_write_protect
,
1246 .tpg_check_prot_fabric_only
= tcm_loop_check_prot_fabric_only
,
1247 .tpg_get_inst_index
= tcm_loop_get_inst_index
,
1248 .check_stop_free
= tcm_loop_check_stop_free
,
1249 .release_cmd
= tcm_loop_release_cmd
,
1250 .shutdown_session
= tcm_loop_shutdown_session
,
1251 .close_session
= tcm_loop_close_session
,
1252 .sess_get_index
= tcm_loop_sess_get_index
,
1253 .write_pending
= tcm_loop_write_pending
,
1254 .write_pending_status
= tcm_loop_write_pending_status
,
1255 .set_default_node_attributes
= tcm_loop_set_default_node_attributes
,
1256 .get_cmd_state
= tcm_loop_get_cmd_state
,
1257 .queue_data_in
= tcm_loop_queue_data_in
,
1258 .queue_status
= tcm_loop_queue_status
,
1259 .queue_tm_rsp
= tcm_loop_queue_tm_rsp
,
1260 .aborted_task
= tcm_loop_aborted_task
,
1261 .fabric_make_wwn
= tcm_loop_make_scsi_hba
,
1262 .fabric_drop_wwn
= tcm_loop_drop_scsi_hba
,
1263 .fabric_make_tpg
= tcm_loop_make_naa_tpg
,
1264 .fabric_drop_tpg
= tcm_loop_drop_naa_tpg
,
1265 .fabric_post_link
= tcm_loop_port_link
,
1266 .fabric_pre_unlink
= tcm_loop_port_unlink
,
1267 .tfc_wwn_attrs
= tcm_loop_wwn_attrs
,
1268 .tfc_tpg_base_attrs
= tcm_loop_tpg_attrs
,
1269 .tfc_tpg_attrib_attrs
= tcm_loop_tpg_attrib_attrs
,
1272 static int __init
tcm_loop_fabric_init(void)
1276 tcm_loop_workqueue
= alloc_workqueue("tcm_loop", 0, 0);
1277 if (!tcm_loop_workqueue
)
1280 tcm_loop_cmd_cache
= kmem_cache_create("tcm_loop_cmd_cache",
1281 sizeof(struct tcm_loop_cmd
),
1282 __alignof__(struct tcm_loop_cmd
),
1284 if (!tcm_loop_cmd_cache
) {
1285 pr_debug("kmem_cache_create() for"
1286 " tcm_loop_cmd_cache failed\n");
1287 goto out_destroy_workqueue
;
1290 ret
= tcm_loop_alloc_core_bus();
1292 goto out_destroy_cache
;
1294 ret
= target_register_template(&loop_ops
);
1296 goto out_release_core_bus
;
1300 out_release_core_bus
:
1301 tcm_loop_release_core_bus();
1303 kmem_cache_destroy(tcm_loop_cmd_cache
);
1304 out_destroy_workqueue
:
1305 destroy_workqueue(tcm_loop_workqueue
);
1310 static void __exit
tcm_loop_fabric_exit(void)
1312 target_unregister_template(&loop_ops
);
1313 tcm_loop_release_core_bus();
1314 kmem_cache_destroy(tcm_loop_cmd_cache
);
1315 destroy_workqueue(tcm_loop_workqueue
);
1318 MODULE_DESCRIPTION("TCM loopback virtual Linux/SCSI fabric module");
1319 MODULE_AUTHOR("Nicholas A. Bellinger <nab@risingtidesystems.com>");
1320 MODULE_LICENSE("GPL");
1321 module_init(tcm_loop_fabric_init
);
1322 module_exit(tcm_loop_fabric_exit
);