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/utsname.h>
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/kthread.h>
26 #include <linux/types.h>
27 #include <linux/string.h>
28 #include <linux/configfs.h>
29 #include <linux/ctype.h>
30 #include <linux/hash.h>
31 #include <linux/percpu_ida.h>
32 #include <asm/unaligned.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/libfc.h>
35 #include <scsi/fc_encode.h>
37 #include <target/target_core_base.h>
38 #include <target/target_core_fabric.h>
43 * Dump cmd state for debugging.
45 static void _ft_dump_cmd(struct ft_cmd
*cmd
, const char *caller
)
49 struct se_cmd
*se_cmd
;
50 struct scatterlist
*sg
;
53 se_cmd
= &cmd
->se_cmd
;
54 pr_debug("%s: cmd %p sess %p seq %p se_cmd %p\n",
55 caller
, cmd
, cmd
->sess
, cmd
->seq
, se_cmd
);
57 pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
58 caller
, cmd
, se_cmd
->t_data_nents
,
59 se_cmd
->data_length
, se_cmd
->se_cmd_flags
);
61 for_each_sg(se_cmd
->t_data_sg
, sg
, se_cmd
->t_data_nents
, count
)
62 pr_debug("%s: cmd %p sg %p page %p "
63 "len 0x%x off 0x%x\n",
65 sg_page(sg
), sg
->length
, sg
->offset
);
70 pr_debug("%s: cmd %p sid %x did %x "
71 "ox_id %x rx_id %x seq_id %x e_stat %x\n",
72 caller
, cmd
, ep
->sid
, ep
->did
, ep
->oxid
, ep
->rxid
,
73 sp
->id
, ep
->esb_stat
);
77 void ft_dump_cmd(struct ft_cmd
*cmd
, const char *caller
)
79 if (unlikely(ft_debug_logging
))
80 _ft_dump_cmd(cmd
, caller
);
83 static void ft_free_cmd(struct ft_cmd
*cmd
)
93 fc_seq_release(fr_seq(fp
));
95 percpu_ida_free(&sess
->se_sess
->sess_tag_pool
, cmd
->se_cmd
.map_tag
);
96 ft_sess_put(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 return transport_generic_free_cmd(se_cmd
, 0);
114 int ft_queue_status(struct se_cmd
*se_cmd
)
116 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
118 struct fcp_resp_with_ext
*fcp
;
119 struct fc_lport
*lport
;
126 ft_dump_cmd(cmd
, __func__
);
127 ep
= fc_seq_exch(cmd
->seq
);
129 len
= sizeof(*fcp
) + se_cmd
->scsi_sense_length
;
130 fp
= fc_frame_alloc(lport
, len
);
132 se_cmd
->scsi_status
= SAM_STAT_TASK_SET_FULL
;
136 fcp
= fc_frame_payload_get(fp
, len
);
138 fcp
->resp
.fr_status
= se_cmd
->scsi_status
;
140 len
= se_cmd
->scsi_sense_length
;
142 fcp
->resp
.fr_flags
|= FCP_SNS_LEN_VAL
;
143 fcp
->ext
.fr_sns_len
= htonl(len
);
144 memcpy((fcp
+ 1), se_cmd
->sense_buffer
, len
);
148 * Test underflow and overflow with one mask. Usually both are off.
149 * Bidirectional commands are not handled yet.
151 if (se_cmd
->se_cmd_flags
& (SCF_OVERFLOW_BIT
| SCF_UNDERFLOW_BIT
)) {
152 if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
)
153 fcp
->resp
.fr_flags
|= FCP_RESID_OVER
;
155 fcp
->resp
.fr_flags
|= FCP_RESID_UNDER
;
156 fcp
->ext
.fr_resid
= cpu_to_be32(se_cmd
->residual_count
);
162 cmd
->seq
= fc_seq_start_next(cmd
->seq
);
163 fc_fill_fc_hdr(fp
, FC_RCTL_DD_CMD_STATUS
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
164 FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
, 0);
166 rc
= fc_seq_send(lport
, cmd
->seq
, fp
);
168 pr_info_ratelimited("%s: Failed to send response frame %p, "
169 "xid <0x%x>\n", __func__
, fp
, ep
->xid
);
171 * Generate a TASK_SET_FULL status to notify the initiator
172 * to reduce it's queue_depth after the se_cmd response has
173 * been re-queued by target-core.
175 se_cmd
->scsi_status
= SAM_STAT_TASK_SET_FULL
;
178 fc_exch_done(cmd
->seq
);
180 * Drop the extra ACK_KREF reference taken by target_submit_cmd()
181 * ahead of ft_check_stop_free() -> transport_generic_free_cmd()
182 * final se_cmd->cmd_kref put.
184 target_put_sess_cmd(&cmd
->se_cmd
);
188 int ft_write_pending_status(struct se_cmd
*se_cmd
)
190 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
192 return cmd
->write_data_len
!= se_cmd
->data_length
;
196 * Send TX_RDY (transfer ready).
198 int ft_write_pending(struct se_cmd
*se_cmd
)
200 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
202 struct fcp_txrdy
*txrdy
;
203 struct fc_lport
*lport
;
205 struct fc_frame_header
*fh
;
208 ft_dump_cmd(cmd
, __func__
);
212 ep
= fc_seq_exch(cmd
->seq
);
214 fp
= fc_frame_alloc(lport
, sizeof(*txrdy
));
216 return -ENOMEM
; /* Signal QUEUE_FULL */
218 txrdy
= fc_frame_payload_get(fp
, sizeof(*txrdy
));
219 memset(txrdy
, 0, sizeof(*txrdy
));
220 txrdy
->ft_burst_len
= htonl(se_cmd
->data_length
);
222 cmd
->seq
= fc_seq_start_next(cmd
->seq
);
223 fc_fill_fc_hdr(fp
, FC_RCTL_DD_DATA_DESC
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
224 FC_FC_EX_CTX
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
226 fh
= fc_frame_header_get(fp
);
227 f_ctl
= ntoh24(fh
->fh_f_ctl
);
229 /* Only if it is 'Exchange Responder' */
230 if (f_ctl
& FC_FC_EX_CTX
) {
231 /* Target is 'exchange responder' and sending XFER_READY
232 * to 'exchange initiator (initiator)'
234 if ((ep
->xid
<= lport
->lro_xid
) &&
235 (fh
->fh_r_ctl
== FC_RCTL_DD_DATA_DESC
)) {
236 if ((se_cmd
->se_cmd_flags
& SCF_SCSI_DATA_CDB
) &&
237 lport
->tt
.ddp_target(lport
, ep
->xid
,
239 se_cmd
->t_data_nents
))
240 cmd
->was_ddp_setup
= 1;
243 fc_seq_send(lport
, cmd
->seq
, fp
);
247 int ft_get_cmd_state(struct se_cmd
*se_cmd
)
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 */
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 fc_seq_send(lport
, sp
, fp
);
327 lport
->tt
.frame_send(lport
, fp
);
332 * Send error or task management response.
334 static void ft_send_resp_code(struct ft_cmd
*cmd
,
335 enum fcp_resp_rsp_codes code
)
337 ft_send_resp_status(cmd
->sess
->tport
->lport
,
338 cmd
->req_frame
, SAM_STAT_GOOD
, code
);
343 * Send error or task management response.
344 * Always frees the cmd and associated state.
346 static void ft_send_resp_code_and_free(struct ft_cmd
*cmd
,
347 enum fcp_resp_rsp_codes code
)
349 ft_send_resp_code(cmd
, code
);
354 * Handle Task Management Request.
356 static void ft_send_tm(struct ft_cmd
*cmd
)
358 struct fcp_cmnd
*fcp
;
362 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
364 switch (fcp
->fc_tm_flags
) {
365 case FCP_TMF_LUN_RESET
:
366 tm_func
= TMR_LUN_RESET
;
368 case FCP_TMF_TGT_RESET
:
369 tm_func
= TMR_TARGET_WARM_RESET
;
371 case FCP_TMF_CLR_TASK_SET
:
372 tm_func
= TMR_CLEAR_TASK_SET
;
374 case FCP_TMF_ABT_TASK_SET
:
375 tm_func
= TMR_ABORT_TASK_SET
;
377 case FCP_TMF_CLR_ACA
:
378 tm_func
= TMR_CLEAR_ACA
;
382 * FCP4r01 indicates having a combination of
383 * tm_flags set is invalid.
385 pr_debug("invalid FCP tm_flags %x\n", fcp
->fc_tm_flags
);
386 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);
390 /* FIXME: Add referenced task tag for ABORT_TASK */
391 rc
= target_submit_tmr(&cmd
->se_cmd
, cmd
->sess
->se_sess
,
392 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
393 cmd
, tm_func
, GFP_KERNEL
, 0, TARGET_SCF_ACK_KREF
);
395 ft_send_resp_code_and_free(cmd
, FCP_TMF_FAILED
);
399 * Send status from completed task management request.
401 void ft_queue_tm_resp(struct se_cmd
*se_cmd
)
403 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
404 struct se_tmr_req
*tmr
= se_cmd
->se_tmr_req
;
405 enum fcp_resp_rsp_codes code
;
409 switch (tmr
->response
) {
410 case TMR_FUNCTION_COMPLETE
:
413 case TMR_LUN_DOES_NOT_EXIST
:
414 code
= FCP_TMF_INVALID_LUN
;
416 case TMR_FUNCTION_REJECTED
:
417 code
= FCP_TMF_REJECTED
;
419 case TMR_TASK_DOES_NOT_EXIST
:
420 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
422 code
= FCP_TMF_FAILED
;
425 pr_debug("tmr fn %d resp %d fcp code %d\n",
426 tmr
->function
, tmr
->response
, code
);
427 ft_send_resp_code(cmd
, code
);
429 * Drop the extra ACK_KREF reference taken by target_submit_tmr()
430 * ahead of ft_check_stop_free() -> transport_generic_free_cmd()
431 * final se_cmd->cmd_kref put.
433 target_put_sess_cmd(&cmd
->se_cmd
);
436 void ft_aborted_task(struct se_cmd
*se_cmd
)
441 static void ft_send_work(struct work_struct
*work
);
444 * Handle incoming FCP command.
446 static void ft_recv_cmd(struct ft_sess
*sess
, struct fc_frame
*fp
)
449 struct fc_lport
*lport
= sess
->tport
->lport
;
450 struct se_session
*se_sess
= sess
->se_sess
;
453 tag
= percpu_ida_alloc(&se_sess
->sess_tag_pool
, TASK_RUNNING
);
457 cmd
= &((struct ft_cmd
*)se_sess
->sess_cmd_map
)[tag
];
458 memset(cmd
, 0, sizeof(struct ft_cmd
));
460 cmd
->se_cmd
.map_tag
= tag
;
462 cmd
->seq
= fc_seq_assign(lport
, fp
);
464 percpu_ida_free(&se_sess
->sess_tag_pool
, tag
);
467 cmd
->req_frame
= fp
; /* hold frame during cmd */
469 INIT_WORK(&cmd
->work
, ft_send_work
);
470 queue_work(sess
->tport
->tpg
->workqueue
, &cmd
->work
);
474 pr_debug("cmd or seq allocation failure - sending BUSY\n");
475 ft_send_resp_status(lport
, fp
, SAM_STAT_BUSY
, 0);
477 ft_sess_put(sess
); /* undo get from lookup */
482 * Handle incoming FCP frame.
483 * Caller has verified that the frame is type FCP.
485 void ft_recv_req(struct ft_sess
*sess
, struct fc_frame
*fp
)
487 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
489 switch (fh
->fh_r_ctl
) {
490 case FC_RCTL_DD_UNSOL_CMD
: /* command */
491 ft_recv_cmd(sess
, fp
);
493 case FC_RCTL_DD_SOL_DATA
: /* write data */
494 case FC_RCTL_DD_UNSOL_CTL
:
495 case FC_RCTL_DD_SOL_CTL
:
496 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
497 case FC_RCTL_ELS4_REQ
: /* SRR, perhaps */
499 pr_debug("%s: unhandled frame r_ctl %x\n",
500 __func__
, fh
->fh_r_ctl
);
502 ft_sess_put(sess
); /* undo get from lookup */
508 * Send new command to target.
510 static void ft_send_work(struct work_struct
*work
)
512 struct ft_cmd
*cmd
= container_of(work
, struct ft_cmd
, work
);
513 struct fc_frame_header
*fh
= fc_frame_header_get(cmd
->req_frame
);
514 struct fcp_cmnd
*fcp
;
518 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
522 if (fcp
->fc_flags
& FCP_CFL_LEN_MASK
)
523 goto err
; /* not handling longer CDBs yet */
526 * Check for FCP task management flags
528 if (fcp
->fc_tm_flags
) {
533 switch (fcp
->fc_flags
& (FCP_CFL_RDDATA
| FCP_CFL_WRDATA
)) {
538 data_dir
= DMA_FROM_DEVICE
;
541 data_dir
= DMA_TO_DEVICE
;
543 case FCP_CFL_WRDATA
| FCP_CFL_RDDATA
:
544 goto err
; /* TBD not supported by tcm_fc yet */
547 * Locate the SAM Task Attr from fc_pri_ta
549 switch (fcp
->fc_pri_ta
& FCP_PTA_MASK
) {
551 task_attr
= TCM_HEAD_TAG
;
553 case FCP_PTA_ORDERED
:
554 task_attr
= TCM_ORDERED_TAG
;
557 task_attr
= TCM_ACA_TAG
;
559 case FCP_PTA_SIMPLE
: /* Fallthrough */
561 task_attr
= TCM_SIMPLE_TAG
;
564 fc_seq_set_resp(cmd
->seq
, ft_recv_seq
, cmd
);
565 cmd
->se_cmd
.tag
= fc_seq_exch(cmd
->seq
)->rxid
;
567 * Use a single se_cmd->cmd_kref as we expect to release se_cmd
568 * directly from ft_check_stop_free callback in response path.
570 if (target_submit_cmd(&cmd
->se_cmd
, cmd
->sess
->se_sess
, fcp
->fc_cdb
,
571 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
572 ntohl(fcp
->fc_dl
), task_attr
, data_dir
,
573 TARGET_SCF_ACK_KREF
| TARGET_SCF_USE_CPUID
))
576 pr_debug("r_ctl %x target_submit_cmd %p\n", fh
->fh_r_ctl
, cmd
);
580 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);