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
,
381 .track_queue_depth
= 1,
384 static int tcm_loop_driver_probe(struct device
*dev
)
386 struct tcm_loop_hba
*tl_hba
;
387 struct Scsi_Host
*sh
;
388 int error
, host_prot
;
390 tl_hba
= to_tcm_loop_hba(dev
);
392 sh
= scsi_host_alloc(&tcm_loop_driver_template
,
393 sizeof(struct tcm_loop_hba
));
395 pr_err("Unable to allocate struct scsi_host\n");
401 * Assign the struct tcm_loop_hba pointer to struct Scsi_Host->hostdata
403 *((struct tcm_loop_hba
**)sh
->hostdata
) = tl_hba
;
405 * Setup single ID, Channel and LUN for now..
410 sh
->max_cmd_len
= SCSI_MAX_VARLEN_CDB_SIZE
;
412 host_prot
= SHOST_DIF_TYPE1_PROTECTION
| SHOST_DIF_TYPE2_PROTECTION
|
413 SHOST_DIF_TYPE3_PROTECTION
| SHOST_DIX_TYPE1_PROTECTION
|
414 SHOST_DIX_TYPE2_PROTECTION
| SHOST_DIX_TYPE3_PROTECTION
;
416 scsi_host_set_prot(sh
, host_prot
);
417 scsi_host_set_guard(sh
, SHOST_DIX_GUARD_CRC
);
419 error
= scsi_add_host(sh
, &tl_hba
->dev
);
421 pr_err("%s: scsi_add_host failed\n", __func__
);
428 static int tcm_loop_driver_remove(struct device
*dev
)
430 struct tcm_loop_hba
*tl_hba
;
431 struct Scsi_Host
*sh
;
433 tl_hba
= to_tcm_loop_hba(dev
);
436 scsi_remove_host(sh
);
441 static void tcm_loop_release_adapter(struct device
*dev
)
443 struct tcm_loop_hba
*tl_hba
= to_tcm_loop_hba(dev
);
449 * Called from tcm_loop_make_scsi_hba() in tcm_loop_configfs.c
451 static int tcm_loop_setup_hba_bus(struct tcm_loop_hba
*tl_hba
, int tcm_loop_host_id
)
455 tl_hba
->dev
.bus
= &tcm_loop_lld_bus
;
456 tl_hba
->dev
.parent
= tcm_loop_primary
;
457 tl_hba
->dev
.release
= &tcm_loop_release_adapter
;
458 dev_set_name(&tl_hba
->dev
, "tcm_loop_adapter_%d", tcm_loop_host_id
);
460 ret
= device_register(&tl_hba
->dev
);
462 pr_err("device_register() failed for"
463 " tl_hba->dev: %d\n", ret
);
471 * Called from tcm_loop_fabric_init() in tcl_loop_fabric.c to load the emulated
474 static int tcm_loop_alloc_core_bus(void)
478 tcm_loop_primary
= root_device_register("tcm_loop_0");
479 if (IS_ERR(tcm_loop_primary
)) {
480 pr_err("Unable to allocate tcm_loop_primary\n");
481 return PTR_ERR(tcm_loop_primary
);
484 ret
= bus_register(&tcm_loop_lld_bus
);
486 pr_err("bus_register() failed for tcm_loop_lld_bus\n");
490 ret
= driver_register(&tcm_loop_driverfs
);
492 pr_err("driver_register() failed for"
493 "tcm_loop_driverfs\n");
497 pr_debug("Initialized TCM Loop Core Bus\n");
501 bus_unregister(&tcm_loop_lld_bus
);
503 root_device_unregister(tcm_loop_primary
);
507 static void tcm_loop_release_core_bus(void)
509 driver_unregister(&tcm_loop_driverfs
);
510 bus_unregister(&tcm_loop_lld_bus
);
511 root_device_unregister(tcm_loop_primary
);
513 pr_debug("Releasing TCM Loop Core BUS\n");
516 static char *tcm_loop_get_fabric_name(void)
521 static inline struct tcm_loop_tpg
*tl_tpg(struct se_portal_group
*se_tpg
)
523 return container_of(se_tpg
, struct tcm_loop_tpg
, tl_se_tpg
);
526 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group
*se_tpg
)
529 * Return the passed NAA identifier for the SAS Target Port
531 return &tl_tpg(se_tpg
)->tl_hba
->tl_wwn_address
[0];
534 static u16
tcm_loop_get_tag(struct se_portal_group
*se_tpg
)
537 * This Tag is used when forming SCSI Name identifier in EVPD=1 0x83
538 * to represent the SCSI Target Port.
540 return tl_tpg(se_tpg
)->tl_tpgt
;
544 * Returning (1) here allows for target_core_mod struct se_node_acl to be generated
545 * based upon the incoming fabric dependent SCSI Initiator Port
547 static int tcm_loop_check_demo_mode(struct se_portal_group
*se_tpg
)
552 static int tcm_loop_check_demo_mode_cache(struct se_portal_group
*se_tpg
)
558 * Allow I_T Nexus full READ-WRITE access without explict Initiator Node ACLs for
559 * local virtual Linux/SCSI LLD passthrough into VM hypervisor guest
561 static int tcm_loop_check_demo_mode_write_protect(struct se_portal_group
*se_tpg
)
567 * Because TCM_Loop does not use explict ACLs and MappedLUNs, this will
568 * never be called for TCM_Loop by target_core_fabric_configfs.c code.
569 * It has been added here as a nop for target_fabric_tf_ops_check()
571 static int tcm_loop_check_prod_mode_write_protect(struct se_portal_group
*se_tpg
)
576 static int tcm_loop_check_prot_fabric_only(struct se_portal_group
*se_tpg
)
578 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
580 return tl_tpg
->tl_fabric_prot_type
;
583 static u32
tcm_loop_get_inst_index(struct se_portal_group
*se_tpg
)
588 static u32
tcm_loop_sess_get_index(struct se_session
*se_sess
)
593 static void tcm_loop_set_default_node_attributes(struct se_node_acl
*se_acl
)
598 static int tcm_loop_get_cmd_state(struct se_cmd
*se_cmd
)
600 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
601 struct tcm_loop_cmd
, tl_se_cmd
);
603 return tl_cmd
->sc_cmd_state
;
606 static int tcm_loop_shutdown_session(struct se_session
*se_sess
)
611 static void tcm_loop_close_session(struct se_session
*se_sess
)
616 static int tcm_loop_write_pending(struct se_cmd
*se_cmd
)
619 * Since Linux/SCSI has already sent down a struct scsi_cmnd
620 * sc->sc_data_direction of DMA_TO_DEVICE with struct scatterlist array
621 * memory, and memory has already been mapped to struct se_cmd->t_mem_list
622 * format with transport_generic_map_mem_to_cmd().
624 * We now tell TCM to add this WRITE CDB directly into the TCM storage
625 * object execution queue.
627 target_execute_cmd(se_cmd
);
631 static int tcm_loop_write_pending_status(struct se_cmd
*se_cmd
)
636 static int tcm_loop_queue_data_in(struct se_cmd
*se_cmd
)
638 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
639 struct tcm_loop_cmd
, tl_se_cmd
);
640 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
642 pr_debug("tcm_loop_queue_data_in() called for scsi_cmnd: %p"
643 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
645 sc
->result
= SAM_STAT_GOOD
;
646 set_host_byte(sc
, DID_OK
);
647 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
648 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
649 scsi_set_resid(sc
, se_cmd
->residual_count
);
654 static int tcm_loop_queue_status(struct se_cmd
*se_cmd
)
656 struct tcm_loop_cmd
*tl_cmd
= container_of(se_cmd
,
657 struct tcm_loop_cmd
, tl_se_cmd
);
658 struct scsi_cmnd
*sc
= tl_cmd
->sc
;
660 pr_debug("tcm_loop_queue_status() called for scsi_cmnd: %p"
661 " cdb: 0x%02x\n", sc
, sc
->cmnd
[0]);
663 if (se_cmd
->sense_buffer
&&
664 ((se_cmd
->se_cmd_flags
& SCF_TRANSPORT_TASK_SENSE
) ||
665 (se_cmd
->se_cmd_flags
& SCF_EMULATED_TASK_SENSE
))) {
667 memcpy(sc
->sense_buffer
, se_cmd
->sense_buffer
,
668 SCSI_SENSE_BUFFERSIZE
);
669 sc
->result
= SAM_STAT_CHECK_CONDITION
;
670 set_driver_byte(sc
, DRIVER_SENSE
);
672 sc
->result
= se_cmd
->scsi_status
;
674 set_host_byte(sc
, DID_OK
);
675 if ((se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
) ||
676 (se_cmd
->se_cmd_flags
& SCF_UNDERFLOW_BIT
))
677 scsi_set_resid(sc
, se_cmd
->residual_count
);
682 static void tcm_loop_queue_tm_rsp(struct se_cmd
*se_cmd
)
684 struct se_tmr_req
*se_tmr
= se_cmd
->se_tmr_req
;
685 struct tcm_loop_tmr
*tl_tmr
= se_tmr
->fabric_tmr_ptr
;
687 * The SCSI EH thread will be sleeping on se_tmr->tl_tmr_wait, go ahead
688 * and wake up the wait_queue_head_t in tcm_loop_device_reset()
690 atomic_set(&tl_tmr
->tmr_complete
, 1);
691 wake_up(&tl_tmr
->tl_tmr_wait
);
694 static void tcm_loop_aborted_task(struct se_cmd
*se_cmd
)
699 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba
*tl_hba
)
701 switch (tl_hba
->tl_proto_id
) {
702 case SCSI_PROTOCOL_SAS
:
704 case SCSI_PROTOCOL_FCP
:
706 case SCSI_PROTOCOL_ISCSI
:
715 /* Start items for tcm_loop_port_cit */
717 static int tcm_loop_port_link(
718 struct se_portal_group
*se_tpg
,
721 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
722 struct tcm_loop_tpg
, tl_se_tpg
);
723 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
725 atomic_inc_mb(&tl_tpg
->tl_tpg_port_count
);
727 * Add Linux/SCSI struct scsi_device by HCTL
729 scsi_add_device(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
, lun
->unpacked_lun
);
731 pr_debug("TCM_Loop_ConfigFS: Port Link Successful\n");
735 static void tcm_loop_port_unlink(
736 struct se_portal_group
*se_tpg
,
737 struct se_lun
*se_lun
)
739 struct scsi_device
*sd
;
740 struct tcm_loop_hba
*tl_hba
;
741 struct tcm_loop_tpg
*tl_tpg
;
743 tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
, tl_se_tpg
);
744 tl_hba
= tl_tpg
->tl_hba
;
746 sd
= scsi_device_lookup(tl_hba
->sh
, 0, tl_tpg
->tl_tpgt
,
747 se_lun
->unpacked_lun
);
749 pr_err("Unable to locate struct scsi_device for %d:%d:"
750 "%llu\n", 0, tl_tpg
->tl_tpgt
, se_lun
->unpacked_lun
);
754 * Remove Linux/SCSI struct scsi_device by HCTL
756 scsi_remove_device(sd
);
759 atomic_dec_mb(&tl_tpg
->tl_tpg_port_count
);
761 pr_debug("TCM_Loop_ConfigFS: Port Unlink Successful\n");
764 /* End items for tcm_loop_port_cit */
766 static ssize_t
tcm_loop_tpg_attrib_show_fabric_prot_type(
767 struct se_portal_group
*se_tpg
,
770 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
773 return sprintf(page
, "%d\n", tl_tpg
->tl_fabric_prot_type
);
776 static ssize_t
tcm_loop_tpg_attrib_store_fabric_prot_type(
777 struct se_portal_group
*se_tpg
,
781 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
, struct tcm_loop_tpg
,
784 int ret
= kstrtoul(page
, 0, &val
);
787 pr_err("kstrtoul() returned %d for fabric_prot_type\n", ret
);
790 if (val
!= 0 && val
!= 1 && val
!= 3) {
791 pr_err("Invalid qla2xxx fabric_prot_type: %lu\n", val
);
794 tl_tpg
->tl_fabric_prot_type
= val
;
799 TF_TPG_ATTRIB_ATTR(tcm_loop
, fabric_prot_type
, S_IRUGO
| S_IWUSR
);
801 static struct configfs_attribute
*tcm_loop_tpg_attrib_attrs
[] = {
802 &tcm_loop_tpg_attrib_fabric_prot_type
.attr
,
806 /* Start items for tcm_loop_nexus_cit */
808 static int tcm_loop_make_nexus(
809 struct tcm_loop_tpg
*tl_tpg
,
812 struct se_portal_group
*se_tpg
;
813 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
814 struct tcm_loop_nexus
*tl_nexus
;
817 if (tl_tpg
->tl_nexus
) {
818 pr_debug("tl_tpg->tl_nexus already exists\n");
821 se_tpg
= &tl_tpg
->tl_se_tpg
;
823 tl_nexus
= kzalloc(sizeof(struct tcm_loop_nexus
), GFP_KERNEL
);
825 pr_err("Unable to allocate struct tcm_loop_nexus\n");
829 * Initialize the struct se_session pointer
831 tl_nexus
->se_sess
= transport_init_session(
832 TARGET_PROT_DIN_PASS
| TARGET_PROT_DOUT_PASS
);
833 if (IS_ERR(tl_nexus
->se_sess
)) {
834 ret
= PTR_ERR(tl_nexus
->se_sess
);
838 * Since we are running in 'demo mode' this call with generate a
839 * struct se_node_acl for the tcm_loop struct se_portal_group with the SCSI
840 * Initiator port name of the passed configfs group 'name'.
842 tl_nexus
->se_sess
->se_node_acl
= core_tpg_check_initiator_node_acl(
843 se_tpg
, (unsigned char *)name
);
844 if (!tl_nexus
->se_sess
->se_node_acl
) {
845 transport_free_session(tl_nexus
->se_sess
);
848 /* Now, register the SAS I_T Nexus as active. */
849 transport_register_session(se_tpg
, tl_nexus
->se_sess
->se_node_acl
,
850 tl_nexus
->se_sess
, tl_nexus
);
851 tl_tpg
->tl_nexus
= tl_nexus
;
852 pr_debug("TCM_Loop_ConfigFS: Established I_T Nexus to emulated"
853 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tl_hba
),
862 static int tcm_loop_drop_nexus(
863 struct tcm_loop_tpg
*tpg
)
865 struct se_session
*se_sess
;
866 struct tcm_loop_nexus
*tl_nexus
;
868 tl_nexus
= tpg
->tl_nexus
;
872 se_sess
= tl_nexus
->se_sess
;
876 if (atomic_read(&tpg
->tl_tpg_port_count
)) {
877 pr_err("Unable to remove TCM_Loop I_T Nexus with"
878 " active TPG port count: %d\n",
879 atomic_read(&tpg
->tl_tpg_port_count
));
883 pr_debug("TCM_Loop_ConfigFS: Removing I_T Nexus to emulated"
884 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tpg
->tl_hba
),
885 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
887 * Release the SCSI I_T Nexus to the emulated SAS Target Port
889 transport_deregister_session(tl_nexus
->se_sess
);
890 tpg
->tl_nexus
= NULL
;
895 /* End items for tcm_loop_nexus_cit */
897 static ssize_t
tcm_loop_tpg_show_nexus(
898 struct se_portal_group
*se_tpg
,
901 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
902 struct tcm_loop_tpg
, tl_se_tpg
);
903 struct tcm_loop_nexus
*tl_nexus
;
906 tl_nexus
= tl_tpg
->tl_nexus
;
910 ret
= snprintf(page
, PAGE_SIZE
, "%s\n",
911 tl_nexus
->se_sess
->se_node_acl
->initiatorname
);
916 static ssize_t
tcm_loop_tpg_store_nexus(
917 struct se_portal_group
*se_tpg
,
921 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
922 struct tcm_loop_tpg
, tl_se_tpg
);
923 struct tcm_loop_hba
*tl_hba
= tl_tpg
->tl_hba
;
924 unsigned char i_port
[TL_WWN_ADDR_LEN
], *ptr
, *port_ptr
;
927 * Shutdown the active I_T nexus if 'NULL' is passed..
929 if (!strncmp(page
, "NULL", 4)) {
930 ret
= tcm_loop_drop_nexus(tl_tpg
);
931 return (!ret
) ? count
: ret
;
934 * Otherwise make sure the passed virtual Initiator port WWN matches
935 * the fabric protocol_id set in tcm_loop_make_scsi_hba(), and call
936 * tcm_loop_make_nexus()
938 if (strlen(page
) >= TL_WWN_ADDR_LEN
) {
939 pr_err("Emulated NAA Sas Address: %s, exceeds"
940 " max: %d\n", page
, TL_WWN_ADDR_LEN
);
943 snprintf(&i_port
[0], TL_WWN_ADDR_LEN
, "%s", page
);
945 ptr
= strstr(i_port
, "naa.");
947 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_SAS
) {
948 pr_err("Passed SAS Initiator Port %s does not"
949 " match target port protoid: %s\n", i_port
,
950 tcm_loop_dump_proto_id(tl_hba
));
953 port_ptr
= &i_port
[0];
956 ptr
= strstr(i_port
, "fc.");
958 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_FCP
) {
959 pr_err("Passed FCP Initiator Port %s does not"
960 " match target port protoid: %s\n", i_port
,
961 tcm_loop_dump_proto_id(tl_hba
));
964 port_ptr
= &i_port
[3]; /* Skip over "fc." */
967 ptr
= strstr(i_port
, "iqn.");
969 if (tl_hba
->tl_proto_id
!= SCSI_PROTOCOL_ISCSI
) {
970 pr_err("Passed iSCSI Initiator Port %s does not"
971 " match target port protoid: %s\n", i_port
,
972 tcm_loop_dump_proto_id(tl_hba
));
975 port_ptr
= &i_port
[0];
978 pr_err("Unable to locate prefix for emulated Initiator Port:"
982 * Clear any trailing newline for the NAA WWN
985 if (i_port
[strlen(i_port
)-1] == '\n')
986 i_port
[strlen(i_port
)-1] = '\0';
988 ret
= tcm_loop_make_nexus(tl_tpg
, port_ptr
);
995 TF_TPG_BASE_ATTR(tcm_loop
, nexus
, S_IRUGO
| S_IWUSR
);
997 static ssize_t
tcm_loop_tpg_show_transport_status(
998 struct se_portal_group
*se_tpg
,
1001 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1002 struct tcm_loop_tpg
, tl_se_tpg
);
1003 const char *status
= NULL
;
1004 ssize_t ret
= -EINVAL
;
1006 switch (tl_tpg
->tl_transport_status
) {
1007 case TCM_TRANSPORT_ONLINE
:
1010 case TCM_TRANSPORT_OFFLINE
:
1018 ret
= snprintf(page
, PAGE_SIZE
, "%s\n", status
);
1023 static ssize_t
tcm_loop_tpg_store_transport_status(
1024 struct se_portal_group
*se_tpg
,
1028 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1029 struct tcm_loop_tpg
, tl_se_tpg
);
1031 if (!strncmp(page
, "online", 6)) {
1032 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_ONLINE
;
1035 if (!strncmp(page
, "offline", 7)) {
1036 tl_tpg
->tl_transport_status
= TCM_TRANSPORT_OFFLINE
;
1042 TF_TPG_BASE_ATTR(tcm_loop
, transport_status
, S_IRUGO
| S_IWUSR
);
1044 static struct configfs_attribute
*tcm_loop_tpg_attrs
[] = {
1045 &tcm_loop_tpg_nexus
.attr
,
1046 &tcm_loop_tpg_transport_status
.attr
,
1050 /* Start items for tcm_loop_naa_cit */
1052 static struct se_portal_group
*tcm_loop_make_naa_tpg(
1054 struct config_group
*group
,
1057 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1058 struct tcm_loop_hba
, tl_hba_wwn
);
1059 struct tcm_loop_tpg
*tl_tpg
;
1063 if (strstr(name
, "tpgt_") != name
) {
1064 pr_err("Unable to locate \"tpgt_#\" directory"
1066 return ERR_PTR(-EINVAL
);
1068 if (kstrtoul(name
+5, 10, &tpgt
))
1069 return ERR_PTR(-EINVAL
);
1071 if (tpgt
>= TL_TPGS_PER_HBA
) {
1072 pr_err("Passed tpgt: %lu exceeds TL_TPGS_PER_HBA:"
1073 " %u\n", tpgt
, TL_TPGS_PER_HBA
);
1074 return ERR_PTR(-EINVAL
);
1076 tl_tpg
= &tl_hba
->tl_hba_tpgs
[tpgt
];
1077 tl_tpg
->tl_hba
= tl_hba
;
1078 tl_tpg
->tl_tpgt
= tpgt
;
1080 * Register the tl_tpg as a emulated SAS TCM Target Endpoint
1082 ret
= core_tpg_register(wwn
, &tl_tpg
->tl_se_tpg
, tl_hba
->tl_proto_id
);
1084 return ERR_PTR(-ENOMEM
);
1086 pr_debug("TCM_Loop_ConfigFS: Allocated Emulated %s"
1087 " Target Port %s,t,0x%04lx\n", tcm_loop_dump_proto_id(tl_hba
),
1088 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1090 return &tl_tpg
->tl_se_tpg
;
1093 static void tcm_loop_drop_naa_tpg(
1094 struct se_portal_group
*se_tpg
)
1096 struct se_wwn
*wwn
= se_tpg
->se_tpg_wwn
;
1097 struct tcm_loop_tpg
*tl_tpg
= container_of(se_tpg
,
1098 struct tcm_loop_tpg
, tl_se_tpg
);
1099 struct tcm_loop_hba
*tl_hba
;
1100 unsigned short tpgt
;
1102 tl_hba
= tl_tpg
->tl_hba
;
1103 tpgt
= tl_tpg
->tl_tpgt
;
1105 * Release the I_T Nexus for the Virtual SAS link if present
1107 tcm_loop_drop_nexus(tl_tpg
);
1109 * Deregister the tl_tpg as a emulated SAS TCM Target Endpoint
1111 core_tpg_deregister(se_tpg
);
1113 tl_tpg
->tl_hba
= NULL
;
1114 tl_tpg
->tl_tpgt
= 0;
1116 pr_debug("TCM_Loop_ConfigFS: Deallocated Emulated %s"
1117 " Target Port %s,t,0x%04x\n", tcm_loop_dump_proto_id(tl_hba
),
1118 config_item_name(&wwn
->wwn_group
.cg_item
), tpgt
);
1121 /* End items for tcm_loop_naa_cit */
1123 /* Start items for tcm_loop_cit */
1125 static struct se_wwn
*tcm_loop_make_scsi_hba(
1126 struct target_fabric_configfs
*tf
,
1127 struct config_group
*group
,
1130 struct tcm_loop_hba
*tl_hba
;
1131 struct Scsi_Host
*sh
;
1135 tl_hba
= kzalloc(sizeof(struct tcm_loop_hba
), GFP_KERNEL
);
1137 pr_err("Unable to allocate struct tcm_loop_hba\n");
1138 return ERR_PTR(-ENOMEM
);
1141 * Determine the emulated Protocol Identifier and Target Port Name
1142 * based on the incoming configfs directory name.
1144 ptr
= strstr(name
, "naa.");
1146 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_SAS
;
1149 ptr
= strstr(name
, "fc.");
1151 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_FCP
;
1152 off
= 3; /* Skip over "fc." */
1155 ptr
= strstr(name
, "iqn.");
1157 pr_err("Unable to locate prefix for emulated Target "
1158 "Port: %s\n", name
);
1162 tl_hba
->tl_proto_id
= SCSI_PROTOCOL_ISCSI
;
1165 if (strlen(name
) >= TL_WWN_ADDR_LEN
) {
1166 pr_err("Emulated NAA %s Address: %s, exceeds"
1167 " max: %d\n", name
, tcm_loop_dump_proto_id(tl_hba
),
1172 snprintf(&tl_hba
->tl_wwn_address
[0], TL_WWN_ADDR_LEN
, "%s", &name
[off
]);
1175 * Call device_register(tl_hba->dev) to register the emulated
1176 * Linux/SCSI LLD of type struct Scsi_Host at tl_hba->sh after
1177 * device_register() callbacks in tcm_loop_driver_probe()
1179 ret
= tcm_loop_setup_hba_bus(tl_hba
, tcm_loop_hba_no_cnt
);
1184 tcm_loop_hba_no_cnt
++;
1185 pr_debug("TCM_Loop_ConfigFS: Allocated emulated Target"
1186 " %s Address: %s at Linux/SCSI Host ID: %d\n",
1187 tcm_loop_dump_proto_id(tl_hba
), name
, sh
->host_no
);
1189 return &tl_hba
->tl_hba_wwn
;
1192 return ERR_PTR(ret
);
1195 static void tcm_loop_drop_scsi_hba(
1198 struct tcm_loop_hba
*tl_hba
= container_of(wwn
,
1199 struct tcm_loop_hba
, tl_hba_wwn
);
1201 pr_debug("TCM_Loop_ConfigFS: Deallocating emulated Target"
1202 " SAS Address: %s at Linux/SCSI Host ID: %d\n",
1203 tl_hba
->tl_wwn_address
, tl_hba
->sh
->host_no
);
1205 * Call device_unregister() on the original tl_hba->dev.
1206 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will
1209 device_unregister(&tl_hba
->dev
);
1212 /* Start items for tcm_loop_cit */
1213 static ssize_t
tcm_loop_wwn_show_attr_version(
1214 struct target_fabric_configfs
*tf
,
1217 return sprintf(page
, "TCM Loopback Fabric module %s\n", TCM_LOOP_VERSION
);
1220 TF_WWN_ATTR_RO(tcm_loop
, version
);
1222 static struct configfs_attribute
*tcm_loop_wwn_attrs
[] = {
1223 &tcm_loop_wwn_version
.attr
,
1227 /* End items for tcm_loop_cit */
1229 static const struct target_core_fabric_ops loop_ops
= {
1230 .module
= THIS_MODULE
,
1232 .get_fabric_name
= tcm_loop_get_fabric_name
,
1233 .tpg_get_wwn
= tcm_loop_get_endpoint_wwn
,
1234 .tpg_get_tag
= tcm_loop_get_tag
,
1235 .tpg_check_demo_mode
= tcm_loop_check_demo_mode
,
1236 .tpg_check_demo_mode_cache
= tcm_loop_check_demo_mode_cache
,
1237 .tpg_check_demo_mode_write_protect
=
1238 tcm_loop_check_demo_mode_write_protect
,
1239 .tpg_check_prod_mode_write_protect
=
1240 tcm_loop_check_prod_mode_write_protect
,
1241 .tpg_check_prot_fabric_only
= tcm_loop_check_prot_fabric_only
,
1242 .tpg_get_inst_index
= tcm_loop_get_inst_index
,
1243 .check_stop_free
= tcm_loop_check_stop_free
,
1244 .release_cmd
= tcm_loop_release_cmd
,
1245 .shutdown_session
= tcm_loop_shutdown_session
,
1246 .close_session
= tcm_loop_close_session
,
1247 .sess_get_index
= tcm_loop_sess_get_index
,
1248 .write_pending
= tcm_loop_write_pending
,
1249 .write_pending_status
= tcm_loop_write_pending_status
,
1250 .set_default_node_attributes
= tcm_loop_set_default_node_attributes
,
1251 .get_cmd_state
= tcm_loop_get_cmd_state
,
1252 .queue_data_in
= tcm_loop_queue_data_in
,
1253 .queue_status
= tcm_loop_queue_status
,
1254 .queue_tm_rsp
= tcm_loop_queue_tm_rsp
,
1255 .aborted_task
= tcm_loop_aborted_task
,
1256 .fabric_make_wwn
= tcm_loop_make_scsi_hba
,
1257 .fabric_drop_wwn
= tcm_loop_drop_scsi_hba
,
1258 .fabric_make_tpg
= tcm_loop_make_naa_tpg
,
1259 .fabric_drop_tpg
= tcm_loop_drop_naa_tpg
,
1260 .fabric_post_link
= tcm_loop_port_link
,
1261 .fabric_pre_unlink
= tcm_loop_port_unlink
,
1262 .tfc_wwn_attrs
= tcm_loop_wwn_attrs
,
1263 .tfc_tpg_base_attrs
= tcm_loop_tpg_attrs
,
1264 .tfc_tpg_attrib_attrs
= tcm_loop_tpg_attrib_attrs
,
1267 static int __init
tcm_loop_fabric_init(void)
1271 tcm_loop_workqueue
= alloc_workqueue("tcm_loop", 0, 0);
1272 if (!tcm_loop_workqueue
)
1275 tcm_loop_cmd_cache
= kmem_cache_create("tcm_loop_cmd_cache",
1276 sizeof(struct tcm_loop_cmd
),
1277 __alignof__(struct tcm_loop_cmd
),
1279 if (!tcm_loop_cmd_cache
) {
1280 pr_debug("kmem_cache_create() for"
1281 " tcm_loop_cmd_cache failed\n");
1282 goto out_destroy_workqueue
;
1285 ret
= tcm_loop_alloc_core_bus();
1287 goto out_destroy_cache
;
1289 ret
= target_register_template(&loop_ops
);
1291 goto out_release_core_bus
;
1295 out_release_core_bus
:
1296 tcm_loop_release_core_bus();
1298 kmem_cache_destroy(tcm_loop_cmd_cache
);
1299 out_destroy_workqueue
:
1300 destroy_workqueue(tcm_loop_workqueue
);
1305 static void __exit
tcm_loop_fabric_exit(void)
1307 target_unregister_template(&loop_ops
);
1308 tcm_loop_release_core_bus();
1309 kmem_cache_destroy(tcm_loop_cmd_cache
);
1310 destroy_workqueue(tcm_loop_workqueue
);
1313 MODULE_DESCRIPTION("TCM loopback virtual Linux/SCSI fabric module");
1314 MODULE_AUTHOR("Nicholas A. Bellinger <nab@risingtidesystems.com>");
1315 MODULE_LICENSE("GPL");
1316 module_init(tcm_loop_fabric_init
);
1317 module_exit(tcm_loop_fabric_exit
);