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
);
63 pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
64 caller
, cmd
, se_cmd
->t_data_nents
,
65 se_cmd
->data_length
, se_cmd
->se_cmd_flags
);
67 for_each_sg(se_cmd
->t_data_sg
, sg
, se_cmd
->t_data_nents
, count
)
68 pr_debug("%s: cmd %p sg %p page %p "
69 "len 0x%x off 0x%x\n",
71 sg_page(sg
), sg
->length
, sg
->offset
);
76 pr_debug("%s: cmd %p sid %x did %x "
77 "ox_id %x rx_id %x seq_id %x e_stat %x\n",
78 caller
, cmd
, ep
->sid
, ep
->did
, ep
->oxid
, ep
->rxid
,
79 sp
->id
, ep
->esb_stat
);
83 static void ft_free_cmd(struct ft_cmd
*cmd
)
86 struct fc_lport
*lport
;
93 lport
->tt
.seq_release(fr_seq(fp
));
95 ft_sess_put(cmd
->sess
); /* undo get from lookup at recv */
99 void ft_release_cmd(struct se_cmd
*se_cmd
)
101 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
106 int ft_check_stop_free(struct se_cmd
*se_cmd
)
108 transport_generic_free_cmd(se_cmd
, 0);
115 int ft_queue_status(struct se_cmd
*se_cmd
)
117 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
119 struct fcp_resp_with_ext
*fcp
;
120 struct fc_lport
*lport
;
124 ft_dump_cmd(cmd
, __func__
);
125 ep
= fc_seq_exch(cmd
->seq
);
127 len
= sizeof(*fcp
) + se_cmd
->scsi_sense_length
;
128 fp
= fc_frame_alloc(lport
, len
);
130 /* XXX shouldn't just drop it - requeue and retry? */
133 fcp
= fc_frame_payload_get(fp
, len
);
135 fcp
->resp
.fr_status
= se_cmd
->scsi_status
;
137 len
= se_cmd
->scsi_sense_length
;
139 fcp
->resp
.fr_flags
|= FCP_SNS_LEN_VAL
;
140 fcp
->ext
.fr_sns_len
= htonl(len
);
141 memcpy((fcp
+ 1), se_cmd
->sense_buffer
, len
);
145 * Test underflow and overflow with one mask. Usually both are off.
146 * Bidirectional commands are not handled yet.
148 if (se_cmd
->se_cmd_flags
& (SCF_OVERFLOW_BIT
| SCF_UNDERFLOW_BIT
)) {
149 if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
)
150 fcp
->resp
.fr_flags
|= FCP_RESID_OVER
;
152 fcp
->resp
.fr_flags
|= FCP_RESID_UNDER
;
153 fcp
->ext
.fr_resid
= cpu_to_be32(se_cmd
->residual_count
);
159 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
160 fc_fill_fc_hdr(fp
, FC_RCTL_DD_CMD_STATUS
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
161 FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
, 0);
163 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
164 lport
->tt
.exch_done(cmd
->seq
);
168 int ft_write_pending_status(struct se_cmd
*se_cmd
)
170 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
172 return cmd
->write_data_len
!= se_cmd
->data_length
;
176 * Send TX_RDY (transfer ready).
178 int ft_write_pending(struct se_cmd
*se_cmd
)
180 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
182 struct fcp_txrdy
*txrdy
;
183 struct fc_lport
*lport
;
185 struct fc_frame_header
*fh
;
188 ft_dump_cmd(cmd
, __func__
);
190 ep
= fc_seq_exch(cmd
->seq
);
192 fp
= fc_frame_alloc(lport
, sizeof(*txrdy
));
194 return -ENOMEM
; /* Signal QUEUE_FULL */
196 txrdy
= fc_frame_payload_get(fp
, sizeof(*txrdy
));
197 memset(txrdy
, 0, sizeof(*txrdy
));
198 txrdy
->ft_burst_len
= htonl(se_cmd
->data_length
);
200 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
201 fc_fill_fc_hdr(fp
, FC_RCTL_DD_DATA_DESC
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
202 FC_FC_EX_CTX
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
204 fh
= fc_frame_header_get(fp
);
205 f_ctl
= ntoh24(fh
->fh_f_ctl
);
207 /* Only if it is 'Exchange Responder' */
208 if (f_ctl
& FC_FC_EX_CTX
) {
209 /* Target is 'exchange responder' and sending XFER_READY
210 * to 'exchange initiator (initiator)'
212 if ((ep
->xid
<= lport
->lro_xid
) &&
213 (fh
->fh_r_ctl
== FC_RCTL_DD_DATA_DESC
)) {
214 if (se_cmd
->se_cmd_flags
& SCF_SCSI_DATA_SG_IO_CDB
) {
216 * cmd may have been broken up into multiple
217 * tasks. Link their sgs together so we can
218 * operate on them all at once.
220 transport_do_task_sg_chain(se_cmd
);
221 cmd
->sg
= se_cmd
->t_tasks_sg_chained
;
223 se_cmd
->t_tasks_sg_chained_no
;
225 if (cmd
->sg
&& lport
->tt
.ddp_target(lport
, ep
->xid
,
228 cmd
->was_ddp_setup
= 1;
231 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
235 u32
ft_get_task_tag(struct se_cmd
*se_cmd
)
237 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
239 return fc_seq_exch(cmd
->seq
)->rxid
;
242 int ft_get_cmd_state(struct se_cmd
*se_cmd
)
247 int ft_is_state_remove(struct se_cmd
*se_cmd
)
249 return 0; /* XXX TBD */
253 * FC sequence response handler for follow-on sequences (data) and aborts.
255 static void ft_recv_seq(struct fc_seq
*sp
, struct fc_frame
*fp
, void *arg
)
257 struct ft_cmd
*cmd
= arg
;
258 struct fc_frame_header
*fh
;
261 /* XXX need to find cmd if queued */
263 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
267 fh
= fc_frame_header_get(fp
);
269 switch (fh
->fh_r_ctl
) {
270 case FC_RCTL_DD_SOL_DATA
: /* write data */
271 ft_recv_write_data(cmd
, fp
);
273 case FC_RCTL_DD_UNSOL_CTL
: /* command */
274 case FC_RCTL_DD_SOL_CTL
: /* transfer ready */
275 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
277 pr_debug("%s: unhandled frame r_ctl %x\n",
278 __func__
, fh
->fh_r_ctl
);
279 ft_invl_hw_context(cmd
);
281 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
287 * Send a FCP response including SCSI status and optional FCP rsp_code.
288 * status is SAM_STAT_GOOD (zero) iff code is valid.
289 * This is used in error cases, such as allocation failures.
291 static void ft_send_resp_status(struct fc_lport
*lport
,
292 const struct fc_frame
*rx_fp
,
293 u32 status
, enum fcp_resp_rsp_codes code
)
297 const struct fc_frame_header
*fh
;
299 struct fcp_resp_with_ext
*fcp
;
300 struct fcp_resp_rsp_info
*info
;
302 fh
= fc_frame_header_get(rx_fp
);
303 pr_debug("FCP error response: did %x oxid %x status %x code %x\n",
304 ntoh24(fh
->fh_s_id
), ntohs(fh
->fh_ox_id
), status
, code
);
306 if (status
== SAM_STAT_GOOD
)
307 len
+= sizeof(*info
);
308 fp
= fc_frame_alloc(lport
, len
);
311 fcp
= fc_frame_payload_get(fp
, len
);
313 fcp
->resp
.fr_status
= status
;
314 if (status
== SAM_STAT_GOOD
) {
315 fcp
->ext
.fr_rsp_len
= htonl(sizeof(*info
));
316 fcp
->resp
.fr_flags
|= FCP_RSP_LEN_VAL
;
317 info
= (struct fcp_resp_rsp_info
*)(fcp
+ 1);
318 info
->rsp_code
= code
;
321 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_DD_CMD_STATUS
, 0);
324 lport
->tt
.seq_send(lport
, sp
, fp
);
326 lport
->tt
.frame_send(lport
, fp
);
330 * Send error or task management response.
332 static void ft_send_resp_code(struct ft_cmd
*cmd
,
333 enum fcp_resp_rsp_codes code
)
335 ft_send_resp_status(cmd
->sess
->tport
->lport
,
336 cmd
->req_frame
, SAM_STAT_GOOD
, code
);
341 * Send error or task management response.
342 * Always frees the cmd and associated state.
344 static void ft_send_resp_code_and_free(struct ft_cmd
*cmd
,
345 enum fcp_resp_rsp_codes code
)
347 ft_send_resp_code(cmd
, code
);
352 * Handle Task Management Request.
354 static void ft_send_tm(struct ft_cmd
*cmd
)
356 struct fcp_cmnd
*fcp
;
357 struct ft_sess
*sess
;
361 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
363 switch (fcp
->fc_tm_flags
) {
364 case FCP_TMF_LUN_RESET
:
365 tm_func
= TMR_LUN_RESET
;
367 case FCP_TMF_TGT_RESET
:
368 tm_func
= TMR_TARGET_WARM_RESET
;
370 case FCP_TMF_CLR_TASK_SET
:
371 tm_func
= TMR_CLEAR_TASK_SET
;
373 case FCP_TMF_ABT_TASK_SET
:
374 tm_func
= TMR_ABORT_TASK_SET
;
376 case FCP_TMF_CLR_ACA
:
377 tm_func
= TMR_CLEAR_ACA
;
381 * FCP4r01 indicates having a combination of
382 * tm_flags set is invalid.
384 pr_debug("invalid FCP tm_flags %x\n", fcp
->fc_tm_flags
);
385 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);
389 transport_init_se_cmd(&cmd
->se_cmd
, &ft_configfs
->tf_ops
,
390 cmd
->sess
->se_sess
, 0, DMA_NONE
, 0,
391 &cmd
->ft_sense_buffer
[0]);
392 target_get_sess_cmd(cmd
->sess
->se_sess
, &cmd
->se_cmd
, false);
394 pr_debug("alloc tm cmd fn %d\n", tm_func
);
395 rc
= core_tmr_alloc_req(&cmd
->se_cmd
, cmd
, tm_func
, GFP_KERNEL
);
397 pr_debug("alloc failed\n");
398 ft_send_resp_code_and_free(cmd
, FCP_TMF_FAILED
);
402 rc
= transport_lookup_tmr_lun(&cmd
->se_cmd
, scsilun_to_int(&fcp
->fc_lun
));
404 pr_debug("Failed to get LUN for TMR func %d, "
405 "se_cmd %p, unpacked_lun %d\n",
406 tm_func
, &cmd
->se_cmd
, scsilun_to_int(&fcp
->fc_lun
));
407 ft_dump_cmd(cmd
, __func__
);
409 transport_send_check_condition_and_sense(&cmd
->se_cmd
,
410 cmd
->se_cmd
.scsi_sense_reason
, 0);
411 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
415 transport_generic_handle_tmr(&cmd
->se_cmd
);
419 * Send status from completed task management request.
421 int ft_queue_tm_resp(struct se_cmd
*se_cmd
)
423 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
424 struct se_tmr_req
*tmr
= se_cmd
->se_tmr_req
;
425 enum fcp_resp_rsp_codes code
;
427 switch (tmr
->response
) {
428 case TMR_FUNCTION_COMPLETE
:
431 case TMR_LUN_DOES_NOT_EXIST
:
432 code
= FCP_TMF_INVALID_LUN
;
434 case TMR_FUNCTION_REJECTED
:
435 code
= FCP_TMF_REJECTED
;
437 case TMR_TASK_DOES_NOT_EXIST
:
438 case TMR_TASK_STILL_ALLEGIANT
:
439 case TMR_TASK_FAILOVER_NOT_SUPPORTED
:
440 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
441 case TMR_FUNCTION_AUTHORIZATION_FAILED
:
443 code
= FCP_TMF_FAILED
;
446 pr_debug("tmr fn %d resp %d fcp code %d\n",
447 tmr
->function
, tmr
->response
, code
);
448 ft_send_resp_code(cmd
, code
);
452 static void ft_send_work(struct work_struct
*work
);
455 * Handle incoming FCP command.
457 static void ft_recv_cmd(struct ft_sess
*sess
, struct fc_frame
*fp
)
460 struct fc_lport
*lport
= sess
->tport
->lport
;
462 cmd
= kzalloc(sizeof(*cmd
), GFP_ATOMIC
);
466 cmd
->seq
= lport
->tt
.seq_assign(lport
, fp
);
471 cmd
->req_frame
= fp
; /* hold frame during cmd */
473 INIT_WORK(&cmd
->work
, ft_send_work
);
474 queue_work(sess
->tport
->tpg
->workqueue
, &cmd
->work
);
478 pr_debug("cmd or seq allocation failure - sending BUSY\n");
479 ft_send_resp_status(lport
, fp
, SAM_STAT_BUSY
, 0);
481 ft_sess_put(sess
); /* undo get from lookup */
486 * Handle incoming FCP frame.
487 * Caller has verified that the frame is type FCP.
489 void ft_recv_req(struct ft_sess
*sess
, struct fc_frame
*fp
)
491 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
493 switch (fh
->fh_r_ctl
) {
494 case FC_RCTL_DD_UNSOL_CMD
: /* command */
495 ft_recv_cmd(sess
, fp
);
497 case FC_RCTL_DD_SOL_DATA
: /* write data */
498 case FC_RCTL_DD_UNSOL_CTL
:
499 case FC_RCTL_DD_SOL_CTL
:
500 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
501 case FC_RCTL_ELS4_REQ
: /* SRR, perhaps */
503 pr_debug("%s: unhandled frame r_ctl %x\n",
504 __func__
, fh
->fh_r_ctl
);
506 ft_sess_put(sess
); /* undo get from lookup */
512 * Send new command to target.
514 static void ft_send_work(struct work_struct
*work
)
516 struct ft_cmd
*cmd
= container_of(work
, struct ft_cmd
, work
);
517 struct fc_frame_header
*fh
= fc_frame_header_get(cmd
->req_frame
);
518 struct fcp_cmnd
*fcp
;
522 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
526 if (fcp
->fc_flags
& FCP_CFL_LEN_MASK
)
527 goto err
; /* not handling longer CDBs yet */
530 * Check for FCP task management flags
532 if (fcp
->fc_tm_flags
) {
537 switch (fcp
->fc_flags
& (FCP_CFL_RDDATA
| FCP_CFL_WRDATA
)) {
542 data_dir
= DMA_FROM_DEVICE
;
545 data_dir
= DMA_TO_DEVICE
;
547 case FCP_CFL_WRDATA
| FCP_CFL_RDDATA
:
548 goto err
; /* TBD not supported by tcm_fc yet */
551 * Locate the SAM Task Attr from fc_pri_ta
553 switch (fcp
->fc_pri_ta
& FCP_PTA_MASK
) {
555 task_attr
= MSG_HEAD_TAG
;
557 case FCP_PTA_ORDERED
:
558 task_attr
= MSG_ORDERED_TAG
;
561 task_attr
= MSG_ACA_TAG
;
563 case FCP_PTA_SIMPLE
: /* Fallthrough */
565 task_attr
= MSG_SIMPLE_TAG
;
568 fc_seq_exch(cmd
->seq
)->lp
->tt
.seq_set_resp(cmd
->seq
, ft_recv_seq
, cmd
);
570 * Use a single se_cmd->cmd_kref as we expect to release se_cmd
571 * directly from ft_check_stop_free callback in response path.
573 target_submit_cmd(&cmd
->se_cmd
, cmd
->sess
->se_sess
, fcp
->fc_cdb
,
574 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
575 ntohl(fcp
->fc_dl
), task_attr
, data_dir
, 0);
576 pr_debug("r_ctl %x alloc target_submit_cmd\n", fh
->fh_r_ctl
);
580 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);