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 <generated/utsrelease.h>
23 #include <linux/utsname.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/kthread.h>
27 #include <linux/types.h>
28 #include <linux/string.h>
29 #include <linux/configfs.h>
30 #include <linux/ctype.h>
31 #include <linux/hash.h>
32 #include <asm/unaligned.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi_device.h>
36 #include <scsi/scsi_cmnd.h>
37 #include <scsi/scsi_tcq.h>
38 #include <scsi/libfc.h>
39 #include <scsi/fc_encode.h>
41 #include <target/target_core_base.h>
42 #include <target/target_core_fabric.h>
43 #include <target/target_core_configfs.h>
44 #include <target/configfs_macros.h>
49 * Dump cmd state for debugging.
51 void ft_dump_cmd(struct ft_cmd
*cmd
, const char *caller
)
55 struct se_cmd
*se_cmd
;
56 struct scatterlist
*sg
;
59 se_cmd
= &cmd
->se_cmd
;
60 pr_debug("%s: cmd %p sess %p seq %p se_cmd %p\n",
61 caller
, cmd
, cmd
->sess
, cmd
->seq
, se_cmd
);
62 pr_debug("%s: cmd %p cdb %p\n",
63 caller
, cmd
, cmd
->cdb
);
65 pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
66 caller
, cmd
, se_cmd
->t_data_nents
,
67 se_cmd
->data_length
, se_cmd
->se_cmd_flags
);
69 for_each_sg(se_cmd
->t_data_sg
, sg
, se_cmd
->t_data_nents
, count
)
70 pr_debug("%s: cmd %p sg %p page %p "
71 "len 0x%x off 0x%x\n",
73 sg_page(sg
), sg
->length
, sg
->offset
);
78 pr_debug("%s: cmd %p sid %x did %x "
79 "ox_id %x rx_id %x seq_id %x e_stat %x\n",
80 caller
, cmd
, ep
->sid
, ep
->did
, ep
->oxid
, ep
->rxid
,
81 sp
->id
, ep
->esb_stat
);
83 print_hex_dump(KERN_INFO
, "ft_dump_cmd ", DUMP_PREFIX_NONE
,
84 16, 4, cmd
->cdb
, MAX_COMMAND_SIZE
, 0);
87 static void ft_free_cmd(struct ft_cmd
*cmd
)
90 struct fc_lport
*lport
;
97 lport
->tt
.seq_release(fr_seq(fp
));
99 ft_sess_put(cmd
->sess
); /* undo get from lookup at recv */
103 void ft_release_cmd(struct se_cmd
*se_cmd
)
105 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
110 int ft_check_stop_free(struct se_cmd
*se_cmd
)
112 transport_generic_free_cmd(se_cmd
, 0);
119 int ft_queue_status(struct se_cmd
*se_cmd
)
121 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
123 struct fcp_resp_with_ext
*fcp
;
124 struct fc_lport
*lport
;
128 ft_dump_cmd(cmd
, __func__
);
129 ep
= fc_seq_exch(cmd
->seq
);
131 len
= sizeof(*fcp
) + se_cmd
->scsi_sense_length
;
132 fp
= fc_frame_alloc(lport
, len
);
134 /* XXX shouldn't just drop it - requeue and retry? */
137 fcp
= fc_frame_payload_get(fp
, len
);
139 fcp
->resp
.fr_status
= se_cmd
->scsi_status
;
141 len
= se_cmd
->scsi_sense_length
;
143 fcp
->resp
.fr_flags
|= FCP_SNS_LEN_VAL
;
144 fcp
->ext
.fr_sns_len
= htonl(len
);
145 memcpy((fcp
+ 1), se_cmd
->sense_buffer
, len
);
149 * Test underflow and overflow with one mask. Usually both are off.
150 * Bidirectional commands are not handled yet.
152 if (se_cmd
->se_cmd_flags
& (SCF_OVERFLOW_BIT
| SCF_UNDERFLOW_BIT
)) {
153 if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
)
154 fcp
->resp
.fr_flags
|= FCP_RESID_OVER
;
156 fcp
->resp
.fr_flags
|= FCP_RESID_UNDER
;
157 fcp
->ext
.fr_resid
= cpu_to_be32(se_cmd
->residual_count
);
163 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
164 fc_fill_fc_hdr(fp
, FC_RCTL_DD_CMD_STATUS
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
165 FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
, 0);
167 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
168 lport
->tt
.exch_done(cmd
->seq
);
172 int ft_write_pending_status(struct se_cmd
*se_cmd
)
174 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
176 return cmd
->write_data_len
!= se_cmd
->data_length
;
180 * Send TX_RDY (transfer ready).
182 int ft_write_pending(struct se_cmd
*se_cmd
)
184 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
186 struct fcp_txrdy
*txrdy
;
187 struct fc_lport
*lport
;
189 struct fc_frame_header
*fh
;
192 ft_dump_cmd(cmd
, __func__
);
194 ep
= fc_seq_exch(cmd
->seq
);
196 fp
= fc_frame_alloc(lport
, sizeof(*txrdy
));
198 return -ENOMEM
; /* Signal QUEUE_FULL */
200 txrdy
= fc_frame_payload_get(fp
, sizeof(*txrdy
));
201 memset(txrdy
, 0, sizeof(*txrdy
));
202 txrdy
->ft_burst_len
= htonl(se_cmd
->data_length
);
204 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
205 fc_fill_fc_hdr(fp
, FC_RCTL_DD_DATA_DESC
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
206 FC_FC_EX_CTX
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
208 fh
= fc_frame_header_get(fp
);
209 f_ctl
= ntoh24(fh
->fh_f_ctl
);
211 /* Only if it is 'Exchange Responder' */
212 if (f_ctl
& FC_FC_EX_CTX
) {
213 /* Target is 'exchange responder' and sending XFER_READY
214 * to 'exchange initiator (initiator)'
216 if ((ep
->xid
<= lport
->lro_xid
) &&
217 (fh
->fh_r_ctl
== FC_RCTL_DD_DATA_DESC
)) {
218 if (se_cmd
->se_cmd_flags
& SCF_SCSI_DATA_SG_IO_CDB
) {
220 * cmd may have been broken up into multiple
221 * tasks. Link their sgs together so we can
222 * operate on them all at once.
224 transport_do_task_sg_chain(se_cmd
);
225 cmd
->sg
= se_cmd
->t_tasks_sg_chained
;
227 se_cmd
->t_tasks_sg_chained_no
;
229 if (cmd
->sg
&& lport
->tt
.ddp_target(lport
, ep
->xid
,
232 cmd
->was_ddp_setup
= 1;
235 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
239 u32
ft_get_task_tag(struct se_cmd
*se_cmd
)
241 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
243 return fc_seq_exch(cmd
->seq
)->rxid
;
246 int ft_get_cmd_state(struct se_cmd
*se_cmd
)
251 int ft_is_state_remove(struct se_cmd
*se_cmd
)
253 return 0; /* XXX TBD */
257 * FC sequence response handler for follow-on sequences (data) and aborts.
259 static void ft_recv_seq(struct fc_seq
*sp
, struct fc_frame
*fp
, void *arg
)
261 struct ft_cmd
*cmd
= arg
;
262 struct fc_frame_header
*fh
;
265 /* XXX need to find cmd if queued */
267 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
271 fh
= fc_frame_header_get(fp
);
273 switch (fh
->fh_r_ctl
) {
274 case FC_RCTL_DD_SOL_DATA
: /* write data */
275 ft_recv_write_data(cmd
, fp
);
277 case FC_RCTL_DD_UNSOL_CTL
: /* command */
278 case FC_RCTL_DD_SOL_CTL
: /* transfer ready */
279 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
281 pr_debug("%s: unhandled frame r_ctl %x\n",
282 __func__
, fh
->fh_r_ctl
);
283 ft_invl_hw_context(cmd
);
285 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
291 * Send a FCP response including SCSI status and optional FCP rsp_code.
292 * status is SAM_STAT_GOOD (zero) iff code is valid.
293 * This is used in error cases, such as allocation failures.
295 static void ft_send_resp_status(struct fc_lport
*lport
,
296 const struct fc_frame
*rx_fp
,
297 u32 status
, enum fcp_resp_rsp_codes code
)
301 const struct fc_frame_header
*fh
;
303 struct fcp_resp_with_ext
*fcp
;
304 struct fcp_resp_rsp_info
*info
;
306 fh
= fc_frame_header_get(rx_fp
);
307 pr_debug("FCP error response: did %x oxid %x status %x code %x\n",
308 ntoh24(fh
->fh_s_id
), ntohs(fh
->fh_ox_id
), status
, code
);
310 if (status
== SAM_STAT_GOOD
)
311 len
+= sizeof(*info
);
312 fp
= fc_frame_alloc(lport
, len
);
315 fcp
= fc_frame_payload_get(fp
, len
);
317 fcp
->resp
.fr_status
= status
;
318 if (status
== SAM_STAT_GOOD
) {
319 fcp
->ext
.fr_rsp_len
= htonl(sizeof(*info
));
320 fcp
->resp
.fr_flags
|= FCP_RSP_LEN_VAL
;
321 info
= (struct fcp_resp_rsp_info
*)(fcp
+ 1);
322 info
->rsp_code
= code
;
325 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_DD_CMD_STATUS
, 0);
328 lport
->tt
.seq_send(lport
, sp
, fp
);
330 lport
->tt
.frame_send(lport
, fp
);
334 * Send error or task management response.
336 static void ft_send_resp_code(struct ft_cmd
*cmd
,
337 enum fcp_resp_rsp_codes code
)
339 ft_send_resp_status(cmd
->sess
->tport
->lport
,
340 cmd
->req_frame
, SAM_STAT_GOOD
, code
);
345 * Send error or task management response.
346 * Always frees the cmd and associated state.
348 static void ft_send_resp_code_and_free(struct ft_cmd
*cmd
,
349 enum fcp_resp_rsp_codes code
)
351 ft_send_resp_code(cmd
, code
);
356 * Handle Task Management Request.
358 static void ft_send_tm(struct ft_cmd
*cmd
)
360 struct se_tmr_req
*tmr
;
361 struct fcp_cmnd
*fcp
;
362 struct ft_sess
*sess
;
365 transport_init_se_cmd(&cmd
->se_cmd
, &ft_configfs
->tf_ops
,
366 cmd
->sess
->se_sess
, 0, DMA_NONE
, 0,
367 &cmd
->ft_sense_buffer
[0]);
368 target_get_sess_cmd(cmd
->sess
->se_sess
, &cmd
->se_cmd
, false);
370 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
372 switch (fcp
->fc_tm_flags
) {
373 case FCP_TMF_LUN_RESET
:
374 tm_func
= TMR_LUN_RESET
;
376 case FCP_TMF_TGT_RESET
:
377 tm_func
= TMR_TARGET_WARM_RESET
;
379 case FCP_TMF_CLR_TASK_SET
:
380 tm_func
= TMR_CLEAR_TASK_SET
;
382 case FCP_TMF_ABT_TASK_SET
:
383 tm_func
= TMR_ABORT_TASK_SET
;
385 case FCP_TMF_CLR_ACA
:
386 tm_func
= TMR_CLEAR_ACA
;
390 * FCP4r01 indicates having a combination of
391 * tm_flags set is invalid.
393 pr_debug("invalid FCP tm_flags %x\n", fcp
->fc_tm_flags
);
394 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);
398 pr_debug("alloc tm cmd fn %d\n", tm_func
);
399 tmr
= core_tmr_alloc_req(&cmd
->se_cmd
, cmd
, tm_func
, GFP_KERNEL
);
401 pr_debug("alloc failed\n");
402 ft_send_resp_code_and_free(cmd
, FCP_TMF_FAILED
);
405 cmd
->se_cmd
.se_tmr_req
= tmr
;
407 switch (fcp
->fc_tm_flags
) {
408 case FCP_TMF_LUN_RESET
:
409 if (transport_lookup_tmr_lun(&cmd
->se_cmd
, scsilun_to_int(&fcp
->fc_lun
)) < 0) {
411 * Make sure to clean up newly allocated TMR request
412 * since "unable to handle TMR request because failed
415 pr_debug("Failed to get LUN for TMR func %d, "
416 "se_cmd %p, unpacked_lun %d\n",
417 tm_func
, &cmd
->se_cmd
, scsilun_to_int(&fcp
->fc_lun
));
418 ft_dump_cmd(cmd
, __func__
);
420 transport_send_check_condition_and_sense(&cmd
->se_cmd
,
421 cmd
->se_cmd
.scsi_sense_reason
, 0);
426 case FCP_TMF_TGT_RESET
:
427 case FCP_TMF_CLR_TASK_SET
:
428 case FCP_TMF_ABT_TASK_SET
:
429 case FCP_TMF_CLR_ACA
:
434 transport_generic_handle_tmr(&cmd
->se_cmd
);
438 * Send status from completed task management request.
440 int ft_queue_tm_resp(struct se_cmd
*se_cmd
)
442 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
443 struct se_tmr_req
*tmr
= se_cmd
->se_tmr_req
;
444 enum fcp_resp_rsp_codes code
;
446 switch (tmr
->response
) {
447 case TMR_FUNCTION_COMPLETE
:
450 case TMR_LUN_DOES_NOT_EXIST
:
451 code
= FCP_TMF_INVALID_LUN
;
453 case TMR_FUNCTION_REJECTED
:
454 code
= FCP_TMF_REJECTED
;
456 case TMR_TASK_DOES_NOT_EXIST
:
457 case TMR_TASK_STILL_ALLEGIANT
:
458 case TMR_TASK_FAILOVER_NOT_SUPPORTED
:
459 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
460 case TMR_FUNCTION_AUTHORIZATION_FAILED
:
462 code
= FCP_TMF_FAILED
;
465 pr_debug("tmr fn %d resp %d fcp code %d\n",
466 tmr
->function
, tmr
->response
, code
);
467 ft_send_resp_code(cmd
, code
);
471 static void ft_send_work(struct work_struct
*work
);
474 * Handle incoming FCP command.
476 static void ft_recv_cmd(struct ft_sess
*sess
, struct fc_frame
*fp
)
479 struct fc_lport
*lport
= sess
->tport
->lport
;
481 cmd
= kzalloc(sizeof(*cmd
), GFP_ATOMIC
);
485 cmd
->seq
= lport
->tt
.seq_assign(lport
, fp
);
490 cmd
->req_frame
= fp
; /* hold frame during cmd */
492 INIT_WORK(&cmd
->work
, ft_send_work
);
493 queue_work(sess
->tport
->tpg
->workqueue
, &cmd
->work
);
497 pr_debug("cmd or seq allocation failure - sending BUSY\n");
498 ft_send_resp_status(lport
, fp
, SAM_STAT_BUSY
, 0);
500 ft_sess_put(sess
); /* undo get from lookup */
505 * Handle incoming FCP frame.
506 * Caller has verified that the frame is type FCP.
508 void ft_recv_req(struct ft_sess
*sess
, struct fc_frame
*fp
)
510 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
512 switch (fh
->fh_r_ctl
) {
513 case FC_RCTL_DD_UNSOL_CMD
: /* command */
514 ft_recv_cmd(sess
, fp
);
516 case FC_RCTL_DD_SOL_DATA
: /* write data */
517 case FC_RCTL_DD_UNSOL_CTL
:
518 case FC_RCTL_DD_SOL_CTL
:
519 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
520 case FC_RCTL_ELS4_REQ
: /* SRR, perhaps */
522 pr_debug("%s: unhandled frame r_ctl %x\n",
523 __func__
, fh
->fh_r_ctl
);
525 ft_sess_put(sess
); /* undo get from lookup */
531 * Send new command to target.
533 static void ft_send_work(struct work_struct
*work
)
535 struct ft_cmd
*cmd
= container_of(work
, struct ft_cmd
, work
);
536 struct fc_frame_header
*fh
= fc_frame_header_get(cmd
->req_frame
);
537 struct fcp_cmnd
*fcp
;
541 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
545 if (fcp
->fc_flags
& FCP_CFL_LEN_MASK
)
546 goto err
; /* not handling longer CDBs yet */
549 * Check for FCP task management flags
551 if (fcp
->fc_tm_flags
) {
556 switch (fcp
->fc_flags
& (FCP_CFL_RDDATA
| FCP_CFL_WRDATA
)) {
561 data_dir
= DMA_FROM_DEVICE
;
564 data_dir
= DMA_TO_DEVICE
;
566 case FCP_CFL_WRDATA
| FCP_CFL_RDDATA
:
567 goto err
; /* TBD not supported by tcm_fc yet */
570 * Locate the SAM Task Attr from fc_pri_ta
572 switch (fcp
->fc_pri_ta
& FCP_PTA_MASK
) {
574 task_attr
= MSG_HEAD_TAG
;
576 case FCP_PTA_ORDERED
:
577 task_attr
= MSG_ORDERED_TAG
;
580 task_attr
= MSG_ACA_TAG
;
582 case FCP_PTA_SIMPLE
: /* Fallthrough */
584 task_attr
= MSG_SIMPLE_TAG
;
587 cmd
->cdb
= fcp
->fc_cdb
;
589 fc_seq_exch(cmd
->seq
)->lp
->tt
.seq_set_resp(cmd
->seq
, ft_recv_seq
, cmd
);
591 * Use a single se_cmd->cmd_kref as we expect to release se_cmd
592 * directly from ft_check_stop_free callback in response path.
594 target_submit_cmd(&cmd
->se_cmd
, cmd
->sess
->se_sess
, cmd
->cdb
,
595 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
596 ntohl(fcp
->fc_dl
), task_attr
, data_dir
, 0);
597 pr_debug("r_ctl %x alloc target_submit_cmd\n", fh
->fh_r_ctl
);
601 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);