2 * Copyright (c) 2010 Cisco Systems, Inc.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 /* XXX TBD some includes may be extraneous */
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/version.h>
23 #include <generated/utsrelease.h>
24 #include <linux/utsname.h>
25 #include <linux/init.h>
26 #include <linux/slab.h>
27 #include <linux/kthread.h>
28 #include <linux/types.h>
29 #include <linux/string.h>
30 #include <linux/configfs.h>
31 #include <linux/ctype.h>
32 #include <linux/hash.h>
33 #include <asm/unaligned.h>
34 #include <scsi/scsi.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_device.h>
37 #include <scsi/scsi_cmnd.h>
38 #include <scsi/scsi_tcq.h>
39 #include <scsi/libfc.h>
40 #include <scsi/fc_encode.h>
42 #include <target/target_core_base.h>
43 #include <target/target_core_transport.h>
44 #include <target/target_core_fabric_ops.h>
45 #include <target/target_core_device.h>
46 #include <target/target_core_tpg.h>
47 #include <target/target_core_configfs.h>
48 #include <target/target_core_base.h>
49 #include <target/target_core_tmr.h>
50 #include <target/configfs_macros.h>
55 * Dump cmd state for debugging.
57 void ft_dump_cmd(struct ft_cmd
*cmd
, const char *caller
)
61 struct se_cmd
*se_cmd
;
62 struct scatterlist
*sg
;
65 se_cmd
= &cmd
->se_cmd
;
66 pr_debug("%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
67 caller
, cmd
, cmd
->state
, cmd
->sess
, cmd
->seq
, se_cmd
);
68 pr_debug("%s: cmd %p cdb %p\n",
69 caller
, cmd
, cmd
->cdb
);
70 pr_debug("%s: cmd %p lun %d\n", caller
, cmd
, cmd
->lun
);
72 pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
73 caller
, cmd
, se_cmd
->t_data_nents
,
74 se_cmd
->data_length
, se_cmd
->se_cmd_flags
);
76 for_each_sg(se_cmd
->t_data_sg
, sg
, se_cmd
->t_data_nents
, count
)
77 pr_debug("%s: cmd %p sg %p page %p "
78 "len 0x%x off 0x%x\n",
80 sg_page(sg
), sg
->length
, sg
->offset
);
85 pr_debug("%s: cmd %p sid %x did %x "
86 "ox_id %x rx_id %x seq_id %x e_stat %x\n",
87 caller
, cmd
, ep
->sid
, ep
->did
, ep
->oxid
, ep
->rxid
,
88 sp
->id
, ep
->esb_stat
);
90 print_hex_dump(KERN_INFO
, "ft_dump_cmd ", DUMP_PREFIX_NONE
,
91 16, 4, cmd
->cdb
, MAX_COMMAND_SIZE
, 0);
94 static void ft_queue_cmd(struct ft_sess
*sess
, struct ft_cmd
*cmd
)
96 struct ft_tpg
*tpg
= sess
->tport
->tpg
;
97 struct se_queue_obj
*qobj
= &tpg
->qobj
;
100 qobj
= &sess
->tport
->tpg
->qobj
;
101 spin_lock_irqsave(&qobj
->cmd_queue_lock
, flags
);
102 list_add_tail(&cmd
->se_req
.qr_list
, &qobj
->qobj_list
);
103 atomic_inc(&qobj
->queue_cnt
);
104 spin_unlock_irqrestore(&qobj
->cmd_queue_lock
, flags
);
106 wake_up_process(tpg
->thread
);
109 static struct ft_cmd
*ft_dequeue_cmd(struct se_queue_obj
*qobj
)
112 struct se_queue_req
*qr
;
114 spin_lock_irqsave(&qobj
->cmd_queue_lock
, flags
);
115 if (list_empty(&qobj
->qobj_list
)) {
116 spin_unlock_irqrestore(&qobj
->cmd_queue_lock
, flags
);
119 qr
= list_first_entry(&qobj
->qobj_list
, struct se_queue_req
, qr_list
);
120 list_del(&qr
->qr_list
);
121 atomic_dec(&qobj
->queue_cnt
);
122 spin_unlock_irqrestore(&qobj
->cmd_queue_lock
, flags
);
123 return container_of(qr
, struct ft_cmd
, se_req
);
126 static void ft_free_cmd(struct ft_cmd
*cmd
)
129 struct fc_lport
*lport
;
136 lport
->tt
.seq_release(fr_seq(fp
));
138 ft_sess_put(cmd
->sess
); /* undo get from lookup at recv */
142 void ft_release_cmd(struct se_cmd
*se_cmd
)
144 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
149 void ft_check_stop_free(struct se_cmd
*se_cmd
)
151 transport_generic_free_cmd(se_cmd
, 0, 0);
157 int ft_queue_status(struct se_cmd
*se_cmd
)
159 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
161 struct fcp_resp_with_ext
*fcp
;
162 struct fc_lport
*lport
;
166 ft_dump_cmd(cmd
, __func__
);
167 ep
= fc_seq_exch(cmd
->seq
);
169 len
= sizeof(*fcp
) + se_cmd
->scsi_sense_length
;
170 fp
= fc_frame_alloc(lport
, len
);
172 /* XXX shouldn't just drop it - requeue and retry? */
175 fcp
= fc_frame_payload_get(fp
, len
);
177 fcp
->resp
.fr_status
= se_cmd
->scsi_status
;
179 len
= se_cmd
->scsi_sense_length
;
181 fcp
->resp
.fr_flags
|= FCP_SNS_LEN_VAL
;
182 fcp
->ext
.fr_sns_len
= htonl(len
);
183 memcpy((fcp
+ 1), se_cmd
->sense_buffer
, len
);
187 * Test underflow and overflow with one mask. Usually both are off.
188 * Bidirectional commands are not handled yet.
190 if (se_cmd
->se_cmd_flags
& (SCF_OVERFLOW_BIT
| SCF_UNDERFLOW_BIT
)) {
191 if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
)
192 fcp
->resp
.fr_flags
|= FCP_RESID_OVER
;
194 fcp
->resp
.fr_flags
|= FCP_RESID_UNDER
;
195 fcp
->ext
.fr_resid
= cpu_to_be32(se_cmd
->residual_count
);
201 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
202 fc_fill_fc_hdr(fp
, FC_RCTL_DD_CMD_STATUS
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
203 FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
, 0);
205 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
206 lport
->tt
.exch_done(cmd
->seq
);
210 int ft_write_pending_status(struct se_cmd
*se_cmd
)
212 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
214 return cmd
->write_data_len
!= se_cmd
->data_length
;
218 * Send TX_RDY (transfer ready).
220 int ft_write_pending(struct se_cmd
*se_cmd
)
222 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
224 struct fcp_txrdy
*txrdy
;
225 struct fc_lport
*lport
;
227 struct fc_frame_header
*fh
;
230 ft_dump_cmd(cmd
, __func__
);
232 ep
= fc_seq_exch(cmd
->seq
);
234 fp
= fc_frame_alloc(lport
, sizeof(*txrdy
));
236 return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES
;
238 txrdy
= fc_frame_payload_get(fp
, sizeof(*txrdy
));
239 memset(txrdy
, 0, sizeof(*txrdy
));
240 txrdy
->ft_burst_len
= htonl(se_cmd
->data_length
);
242 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
243 fc_fill_fc_hdr(fp
, FC_RCTL_DD_DATA_DESC
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
244 FC_FC_EX_CTX
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
246 fh
= fc_frame_header_get(fp
);
247 f_ctl
= ntoh24(fh
->fh_f_ctl
);
249 /* Only if it is 'Exchange Responder' */
250 if (f_ctl
& FC_FC_EX_CTX
) {
251 /* Target is 'exchange responder' and sending XFER_READY
252 * to 'exchange initiator (initiator)'
254 if ((ep
->xid
<= lport
->lro_xid
) &&
255 (fh
->fh_r_ctl
== FC_RCTL_DD_DATA_DESC
)) {
256 if (se_cmd
->se_cmd_flags
& SCF_SCSI_DATA_SG_IO_CDB
) {
258 * cmd may have been broken up into multiple
259 * tasks. Link their sgs together so we can
260 * operate on them all at once.
262 transport_do_task_sg_chain(se_cmd
);
263 cmd
->sg
= se_cmd
->t_tasks_sg_chained
;
265 se_cmd
->t_tasks_sg_chained_no
;
267 if (cmd
->sg
&& lport
->tt
.ddp_setup(lport
, ep
->xid
,
268 cmd
->sg
, cmd
->sg_cnt
))
269 cmd
->was_ddp_setup
= 1;
272 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
276 u32
ft_get_task_tag(struct se_cmd
*se_cmd
)
278 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
280 return fc_seq_exch(cmd
->seq
)->rxid
;
283 int ft_get_cmd_state(struct se_cmd
*se_cmd
)
285 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
290 int ft_is_state_remove(struct se_cmd
*se_cmd
)
292 return 0; /* XXX TBD */
296 * FC sequence response handler for follow-on sequences (data) and aborts.
298 static void ft_recv_seq(struct fc_seq
*sp
, struct fc_frame
*fp
, void *arg
)
300 struct ft_cmd
*cmd
= arg
;
301 struct fc_frame_header
*fh
;
304 /* XXX need to find cmd if queued */
305 cmd
->se_cmd
.t_state
= TRANSPORT_REMOVE
;
307 transport_generic_free_cmd(&cmd
->se_cmd
, 0, 0);
311 fh
= fc_frame_header_get(fp
);
313 switch (fh
->fh_r_ctl
) {
314 case FC_RCTL_DD_SOL_DATA
: /* write data */
315 ft_recv_write_data(cmd
, fp
);
317 case FC_RCTL_DD_UNSOL_CTL
: /* command */
318 case FC_RCTL_DD_SOL_CTL
: /* transfer ready */
319 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
321 pr_debug("%s: unhandled frame r_ctl %x\n",
322 __func__
, fh
->fh_r_ctl
);
324 transport_generic_free_cmd(&cmd
->se_cmd
, 0, 0);
330 * Send a FCP response including SCSI status and optional FCP rsp_code.
331 * status is SAM_STAT_GOOD (zero) iff code is valid.
332 * This is used in error cases, such as allocation failures.
334 static void ft_send_resp_status(struct fc_lport
*lport
,
335 const struct fc_frame
*rx_fp
,
336 u32 status
, enum fcp_resp_rsp_codes code
)
340 const struct fc_frame_header
*fh
;
342 struct fcp_resp_with_ext
*fcp
;
343 struct fcp_resp_rsp_info
*info
;
345 fh
= fc_frame_header_get(rx_fp
);
346 pr_debug("FCP error response: did %x oxid %x status %x code %x\n",
347 ntoh24(fh
->fh_s_id
), ntohs(fh
->fh_ox_id
), status
, code
);
349 if (status
== SAM_STAT_GOOD
)
350 len
+= sizeof(*info
);
351 fp
= fc_frame_alloc(lport
, len
);
354 fcp
= fc_frame_payload_get(fp
, len
);
356 fcp
->resp
.fr_status
= status
;
357 if (status
== SAM_STAT_GOOD
) {
358 fcp
->ext
.fr_rsp_len
= htonl(sizeof(*info
));
359 fcp
->resp
.fr_flags
|= FCP_RSP_LEN_VAL
;
360 info
= (struct fcp_resp_rsp_info
*)(fcp
+ 1);
361 info
->rsp_code
= code
;
364 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_DD_CMD_STATUS
, 0);
367 lport
->tt
.seq_send(lport
, sp
, fp
);
369 lport
->tt
.frame_send(lport
, fp
);
373 * Send error or task management response.
374 * Always frees the cmd and associated state.
376 static void ft_send_resp_code(struct ft_cmd
*cmd
, enum fcp_resp_rsp_codes code
)
378 ft_send_resp_status(cmd
->sess
->tport
->lport
,
379 cmd
->req_frame
, SAM_STAT_GOOD
, code
);
384 * Handle Task Management Request.
386 static void ft_send_tm(struct ft_cmd
*cmd
)
388 struct se_tmr_req
*tmr
;
389 struct fcp_cmnd
*fcp
;
390 struct ft_sess
*sess
;
393 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
395 switch (fcp
->fc_tm_flags
) {
396 case FCP_TMF_LUN_RESET
:
397 tm_func
= TMR_LUN_RESET
;
399 case FCP_TMF_TGT_RESET
:
400 tm_func
= TMR_TARGET_WARM_RESET
;
402 case FCP_TMF_CLR_TASK_SET
:
403 tm_func
= TMR_CLEAR_TASK_SET
;
405 case FCP_TMF_ABT_TASK_SET
:
406 tm_func
= TMR_ABORT_TASK_SET
;
408 case FCP_TMF_CLR_ACA
:
409 tm_func
= TMR_CLEAR_ACA
;
413 * FCP4r01 indicates having a combination of
414 * tm_flags set is invalid.
416 pr_debug("invalid FCP tm_flags %x\n", fcp
->fc_tm_flags
);
417 ft_send_resp_code(cmd
, FCP_CMND_FIELDS_INVALID
);
421 pr_debug("alloc tm cmd fn %d\n", tm_func
);
422 tmr
= core_tmr_alloc_req(&cmd
->se_cmd
, cmd
, tm_func
);
424 pr_debug("alloc failed\n");
425 ft_send_resp_code(cmd
, FCP_TMF_FAILED
);
428 cmd
->se_cmd
.se_tmr_req
= tmr
;
430 switch (fcp
->fc_tm_flags
) {
431 case FCP_TMF_LUN_RESET
:
432 cmd
->lun
= scsilun_to_int((struct scsi_lun
*)fcp
->fc_lun
);
433 if (transport_lookup_tmr_lun(&cmd
->se_cmd
, cmd
->lun
) < 0) {
435 * Make sure to clean up newly allocated TMR request
436 * since "unable to handle TMR request because failed
439 pr_debug("Failed to get LUN for TMR func %d, "
440 "se_cmd %p, unpacked_lun %d\n",
441 tm_func
, &cmd
->se_cmd
, cmd
->lun
);
442 ft_dump_cmd(cmd
, __func__
);
444 transport_send_check_condition_and_sense(&cmd
->se_cmd
,
445 cmd
->se_cmd
.scsi_sense_reason
, 0);
446 transport_generic_free_cmd(&cmd
->se_cmd
, 0, 0);
451 case FCP_TMF_TGT_RESET
:
452 case FCP_TMF_CLR_TASK_SET
:
453 case FCP_TMF_ABT_TASK_SET
:
454 case FCP_TMF_CLR_ACA
:
459 transport_generic_handle_tmr(&cmd
->se_cmd
);
463 * Send status from completed task management request.
465 int ft_queue_tm_resp(struct se_cmd
*se_cmd
)
467 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
468 struct se_tmr_req
*tmr
= se_cmd
->se_tmr_req
;
469 enum fcp_resp_rsp_codes code
;
471 switch (tmr
->response
) {
472 case TMR_FUNCTION_COMPLETE
:
475 case TMR_LUN_DOES_NOT_EXIST
:
476 code
= FCP_TMF_INVALID_LUN
;
478 case TMR_FUNCTION_REJECTED
:
479 code
= FCP_TMF_REJECTED
;
481 case TMR_TASK_DOES_NOT_EXIST
:
482 case TMR_TASK_STILL_ALLEGIANT
:
483 case TMR_TASK_FAILOVER_NOT_SUPPORTED
:
484 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
485 case TMR_FUNCTION_AUTHORIZATION_FAILED
:
487 code
= FCP_TMF_FAILED
;
490 pr_debug("tmr fn %d resp %d fcp code %d\n",
491 tmr
->function
, tmr
->response
, code
);
492 ft_send_resp_code(cmd
, code
);
497 * Handle incoming FCP command.
499 static void ft_recv_cmd(struct ft_sess
*sess
, struct fc_frame
*fp
)
502 struct fc_lport
*lport
= sess
->tport
->lport
;
504 cmd
= kzalloc(sizeof(*cmd
), GFP_ATOMIC
);
508 cmd
->seq
= lport
->tt
.seq_assign(lport
, fp
);
513 cmd
->req_frame
= fp
; /* hold frame during cmd */
514 ft_queue_cmd(sess
, cmd
);
518 pr_debug("cmd or seq allocation failure - sending BUSY\n");
519 ft_send_resp_status(lport
, fp
, SAM_STAT_BUSY
, 0);
521 ft_sess_put(sess
); /* undo get from lookup */
526 * Handle incoming FCP frame.
527 * Caller has verified that the frame is type FCP.
529 void ft_recv_req(struct ft_sess
*sess
, struct fc_frame
*fp
)
531 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
533 switch (fh
->fh_r_ctl
) {
534 case FC_RCTL_DD_UNSOL_CMD
: /* command */
535 ft_recv_cmd(sess
, fp
);
537 case FC_RCTL_DD_SOL_DATA
: /* write data */
538 case FC_RCTL_DD_UNSOL_CTL
:
539 case FC_RCTL_DD_SOL_CTL
:
540 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
541 case FC_RCTL_ELS4_REQ
: /* SRR, perhaps */
543 pr_debug("%s: unhandled frame r_ctl %x\n",
544 __func__
, fh
->fh_r_ctl
);
546 ft_sess_put(sess
); /* undo get from lookup */
552 * Send new command to target.
554 static void ft_send_cmd(struct ft_cmd
*cmd
)
556 struct fc_frame_header
*fh
= fc_frame_header_get(cmd
->req_frame
);
557 struct se_cmd
*se_cmd
;
558 struct fcp_cmnd
*fcp
;
564 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
568 if (fcp
->fc_flags
& FCP_CFL_LEN_MASK
)
569 goto err
; /* not handling longer CDBs yet */
571 if (fcp
->fc_tm_flags
) {
572 task_attr
= FCP_PTA_SIMPLE
;
576 switch (fcp
->fc_flags
& (FCP_CFL_RDDATA
| FCP_CFL_WRDATA
)) {
581 data_dir
= DMA_FROM_DEVICE
;
584 data_dir
= DMA_TO_DEVICE
;
586 case FCP_CFL_WRDATA
| FCP_CFL_RDDATA
:
587 goto err
; /* TBD not supported by tcm_fc yet */
590 * Locate the SAM Task Attr from fc_pri_ta
592 switch (fcp
->fc_pri_ta
& FCP_PTA_MASK
) {
594 task_attr
= MSG_HEAD_TAG
;
596 case FCP_PTA_ORDERED
:
597 task_attr
= MSG_ORDERED_TAG
;
600 task_attr
= MSG_ACA_TAG
;
602 case FCP_PTA_SIMPLE
: /* Fallthrough */
604 task_attr
= MSG_SIMPLE_TAG
;
608 task_attr
= fcp
->fc_pri_ta
& FCP_PTA_MASK
;
609 data_len
= ntohl(fcp
->fc_dl
);
610 cmd
->cdb
= fcp
->fc_cdb
;
613 se_cmd
= &cmd
->se_cmd
;
615 * Initialize struct se_cmd descriptor from target_core_mod
618 transport_init_se_cmd(se_cmd
, &ft_configfs
->tf_ops
, cmd
->sess
->se_sess
,
619 data_len
, data_dir
, task_attr
,
620 &cmd
->ft_sense_buffer
[0]);
622 * Check for FCP task management flags
624 if (fcp
->fc_tm_flags
) {
629 fc_seq_exch(cmd
->seq
)->lp
->tt
.seq_set_resp(cmd
->seq
, ft_recv_seq
, cmd
);
631 cmd
->lun
= scsilun_to_int((struct scsi_lun
*)fcp
->fc_lun
);
632 ret
= transport_lookup_cmd_lun(&cmd
->se_cmd
, cmd
->lun
);
634 ft_dump_cmd(cmd
, __func__
);
635 transport_send_check_condition_and_sense(&cmd
->se_cmd
,
636 cmd
->se_cmd
.scsi_sense_reason
, 0);
640 ret
= transport_generic_allocate_tasks(se_cmd
, cmd
->cdb
);
642 pr_debug("r_ctl %x alloc task ret %d\n", fh
->fh_r_ctl
, ret
);
643 ft_dump_cmd(cmd
, __func__
);
645 if (ret
== -ENOMEM
) {
646 transport_send_check_condition_and_sense(se_cmd
,
647 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE
, 0);
648 transport_generic_free_cmd(se_cmd
, 0, 0);
651 if (ret
== -EINVAL
) {
652 if (se_cmd
->se_cmd_flags
& SCF_SCSI_RESERVATION_CONFLICT
)
653 ft_queue_status(se_cmd
);
655 transport_send_check_condition_and_sense(se_cmd
,
656 se_cmd
->scsi_sense_reason
, 0);
657 transport_generic_free_cmd(se_cmd
, 0, 0);
660 transport_generic_handle_cdb(se_cmd
);
664 ft_send_resp_code(cmd
, FCP_CMND_FIELDS_INVALID
);
668 * Handle request in the command thread.
670 static void ft_exec_req(struct ft_cmd
*cmd
)
672 pr_debug("cmd state %x\n", cmd
->state
);
673 switch (cmd
->state
) {
684 * Currently one thread per tpg.
686 int ft_thread(void *arg
)
688 struct ft_tpg
*tpg
= arg
;
689 struct se_queue_obj
*qobj
= &tpg
->qobj
;
692 while (!kthread_should_stop()) {
693 schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT
);
694 if (kthread_should_stop())
697 cmd
= ft_dequeue_cmd(qobj
);