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
;
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 /* XXX shouldn't just drop it - requeue and retry? */
135 fcp
= fc_frame_payload_get(fp
, len
);
137 fcp
->resp
.fr_status
= se_cmd
->scsi_status
;
139 len
= se_cmd
->scsi_sense_length
;
141 fcp
->resp
.fr_flags
|= FCP_SNS_LEN_VAL
;
142 fcp
->ext
.fr_sns_len
= htonl(len
);
143 memcpy((fcp
+ 1), se_cmd
->sense_buffer
, len
);
147 * Test underflow and overflow with one mask. Usually both are off.
148 * Bidirectional commands are not handled yet.
150 if (se_cmd
->se_cmd_flags
& (SCF_OVERFLOW_BIT
| SCF_UNDERFLOW_BIT
)) {
151 if (se_cmd
->se_cmd_flags
& SCF_OVERFLOW_BIT
)
152 fcp
->resp
.fr_flags
|= FCP_RESID_OVER
;
154 fcp
->resp
.fr_flags
|= FCP_RESID_UNDER
;
155 fcp
->ext
.fr_resid
= cpu_to_be32(se_cmd
->residual_count
);
161 cmd
->seq
= lport
->tt
.seq_start_next(cmd
->seq
);
162 fc_fill_fc_hdr(fp
, FC_RCTL_DD_CMD_STATUS
, ep
->did
, ep
->sid
, FC_TYPE_FCP
,
163 FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
, 0);
165 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
166 lport
->tt
.exch_done(cmd
->seq
);
170 int ft_write_pending_status(struct se_cmd
*se_cmd
)
172 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
174 return cmd
->write_data_len
!= se_cmd
->data_length
;
178 * Send TX_RDY (transfer ready).
180 int ft_write_pending(struct se_cmd
*se_cmd
)
182 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
184 struct fcp_txrdy
*txrdy
;
185 struct fc_lport
*lport
;
187 struct fc_frame_header
*fh
;
190 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_CDB
) &&
219 lport
->tt
.ddp_target(lport
, ep
->xid
,
221 se_cmd
->t_data_nents
))
222 cmd
->was_ddp_setup
= 1;
225 lport
->tt
.seq_send(lport
, cmd
->seq
, fp
);
229 u32
ft_get_task_tag(struct se_cmd
*se_cmd
)
231 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
235 return fc_seq_exch(cmd
->seq
)->rxid
;
238 int ft_get_cmd_state(struct se_cmd
*se_cmd
)
244 * FC sequence response handler for follow-on sequences (data) and aborts.
246 static void ft_recv_seq(struct fc_seq
*sp
, struct fc_frame
*fp
, void *arg
)
248 struct ft_cmd
*cmd
= arg
;
249 struct fc_frame_header
*fh
;
251 if (unlikely(IS_ERR(fp
))) {
252 /* XXX need to find cmd if queued */
258 fh
= fc_frame_header_get(fp
);
260 switch (fh
->fh_r_ctl
) {
261 case FC_RCTL_DD_SOL_DATA
: /* write data */
262 ft_recv_write_data(cmd
, fp
);
264 case FC_RCTL_DD_UNSOL_CTL
: /* command */
265 case FC_RCTL_DD_SOL_CTL
: /* transfer ready */
266 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
268 pr_debug("%s: unhandled frame r_ctl %x\n",
269 __func__
, fh
->fh_r_ctl
);
270 ft_invl_hw_context(cmd
);
272 transport_generic_free_cmd(&cmd
->se_cmd
, 0);
278 * Send a FCP response including SCSI status and optional FCP rsp_code.
279 * status is SAM_STAT_GOOD (zero) iff code is valid.
280 * This is used in error cases, such as allocation failures.
282 static void ft_send_resp_status(struct fc_lport
*lport
,
283 const struct fc_frame
*rx_fp
,
284 u32 status
, enum fcp_resp_rsp_codes code
)
288 const struct fc_frame_header
*fh
;
290 struct fcp_resp_with_ext
*fcp
;
291 struct fcp_resp_rsp_info
*info
;
293 fh
= fc_frame_header_get(rx_fp
);
294 pr_debug("FCP error response: did %x oxid %x status %x code %x\n",
295 ntoh24(fh
->fh_s_id
), ntohs(fh
->fh_ox_id
), status
, code
);
297 if (status
== SAM_STAT_GOOD
)
298 len
+= sizeof(*info
);
299 fp
= fc_frame_alloc(lport
, len
);
302 fcp
= fc_frame_payload_get(fp
, len
);
304 fcp
->resp
.fr_status
= status
;
305 if (status
== SAM_STAT_GOOD
) {
306 fcp
->ext
.fr_rsp_len
= htonl(sizeof(*info
));
307 fcp
->resp
.fr_flags
|= FCP_RSP_LEN_VAL
;
308 info
= (struct fcp_resp_rsp_info
*)(fcp
+ 1);
309 info
->rsp_code
= code
;
312 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_DD_CMD_STATUS
, 0);
315 lport
->tt
.seq_send(lport
, sp
, fp
);
316 lport
->tt
.exch_done(sp
);
318 lport
->tt
.frame_send(lport
, fp
);
323 * Send error or task management response.
325 static void ft_send_resp_code(struct ft_cmd
*cmd
,
326 enum fcp_resp_rsp_codes code
)
328 ft_send_resp_status(cmd
->sess
->tport
->lport
,
329 cmd
->req_frame
, SAM_STAT_GOOD
, code
);
334 * Send error or task management response.
335 * Always frees the cmd and associated state.
337 static void ft_send_resp_code_and_free(struct ft_cmd
*cmd
,
338 enum fcp_resp_rsp_codes code
)
340 ft_send_resp_code(cmd
, code
);
345 * Handle Task Management Request.
347 static void ft_send_tm(struct ft_cmd
*cmd
)
349 struct fcp_cmnd
*fcp
;
353 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
355 switch (fcp
->fc_tm_flags
) {
356 case FCP_TMF_LUN_RESET
:
357 tm_func
= TMR_LUN_RESET
;
359 case FCP_TMF_TGT_RESET
:
360 tm_func
= TMR_TARGET_WARM_RESET
;
362 case FCP_TMF_CLR_TASK_SET
:
363 tm_func
= TMR_CLEAR_TASK_SET
;
365 case FCP_TMF_ABT_TASK_SET
:
366 tm_func
= TMR_ABORT_TASK_SET
;
368 case FCP_TMF_CLR_ACA
:
369 tm_func
= TMR_CLEAR_ACA
;
373 * FCP4r01 indicates having a combination of
374 * tm_flags set is invalid.
376 pr_debug("invalid FCP tm_flags %x\n", fcp
->fc_tm_flags
);
377 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);
381 /* FIXME: Add referenced task tag for ABORT_TASK */
382 rc
= target_submit_tmr(&cmd
->se_cmd
, cmd
->sess
->se_sess
,
383 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
384 cmd
, tm_func
, GFP_KERNEL
, 0, 0);
386 ft_send_resp_code_and_free(cmd
, FCP_TMF_FAILED
);
390 * Send status from completed task management request.
392 int ft_queue_tm_resp(struct se_cmd
*se_cmd
)
394 struct ft_cmd
*cmd
= container_of(se_cmd
, struct ft_cmd
, se_cmd
);
395 struct se_tmr_req
*tmr
= se_cmd
->se_tmr_req
;
396 enum fcp_resp_rsp_codes code
;
400 switch (tmr
->response
) {
401 case TMR_FUNCTION_COMPLETE
:
404 case TMR_LUN_DOES_NOT_EXIST
:
405 code
= FCP_TMF_INVALID_LUN
;
407 case TMR_FUNCTION_REJECTED
:
408 code
= FCP_TMF_REJECTED
;
410 case TMR_TASK_DOES_NOT_EXIST
:
411 case TMR_TASK_STILL_ALLEGIANT
:
412 case TMR_TASK_FAILOVER_NOT_SUPPORTED
:
413 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED
:
414 case TMR_FUNCTION_AUTHORIZATION_FAILED
:
416 code
= FCP_TMF_FAILED
;
419 pr_debug("tmr fn %d resp %d fcp code %d\n",
420 tmr
->function
, tmr
->response
, code
);
421 ft_send_resp_code(cmd
, code
);
425 static void ft_send_work(struct work_struct
*work
);
428 * Handle incoming FCP command.
430 static void ft_recv_cmd(struct ft_sess
*sess
, struct fc_frame
*fp
)
433 struct fc_lport
*lport
= sess
->tport
->lport
;
435 cmd
= kzalloc(sizeof(*cmd
), GFP_ATOMIC
);
439 cmd
->seq
= lport
->tt
.seq_assign(lport
, fp
);
444 cmd
->req_frame
= fp
; /* hold frame during cmd */
446 INIT_WORK(&cmd
->work
, ft_send_work
);
447 queue_work(sess
->tport
->tpg
->workqueue
, &cmd
->work
);
451 pr_debug("cmd or seq allocation failure - sending BUSY\n");
452 ft_send_resp_status(lport
, fp
, SAM_STAT_BUSY
, 0);
454 ft_sess_put(sess
); /* undo get from lookup */
459 * Handle incoming FCP frame.
460 * Caller has verified that the frame is type FCP.
462 void ft_recv_req(struct ft_sess
*sess
, struct fc_frame
*fp
)
464 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
466 switch (fh
->fh_r_ctl
) {
467 case FC_RCTL_DD_UNSOL_CMD
: /* command */
468 ft_recv_cmd(sess
, fp
);
470 case FC_RCTL_DD_SOL_DATA
: /* write data */
471 case FC_RCTL_DD_UNSOL_CTL
:
472 case FC_RCTL_DD_SOL_CTL
:
473 case FC_RCTL_DD_DATA_DESC
: /* transfer ready */
474 case FC_RCTL_ELS4_REQ
: /* SRR, perhaps */
476 pr_debug("%s: unhandled frame r_ctl %x\n",
477 __func__
, fh
->fh_r_ctl
);
479 ft_sess_put(sess
); /* undo get from lookup */
485 * Send new command to target.
487 static void ft_send_work(struct work_struct
*work
)
489 struct ft_cmd
*cmd
= container_of(work
, struct ft_cmd
, work
);
490 struct fc_frame_header
*fh
= fc_frame_header_get(cmd
->req_frame
);
491 struct fcp_cmnd
*fcp
;
495 fcp
= fc_frame_payload_get(cmd
->req_frame
, sizeof(*fcp
));
499 if (fcp
->fc_flags
& FCP_CFL_LEN_MASK
)
500 goto err
; /* not handling longer CDBs yet */
503 * Check for FCP task management flags
505 if (fcp
->fc_tm_flags
) {
510 switch (fcp
->fc_flags
& (FCP_CFL_RDDATA
| FCP_CFL_WRDATA
)) {
515 data_dir
= DMA_FROM_DEVICE
;
518 data_dir
= DMA_TO_DEVICE
;
520 case FCP_CFL_WRDATA
| FCP_CFL_RDDATA
:
521 goto err
; /* TBD not supported by tcm_fc yet */
524 * Locate the SAM Task Attr from fc_pri_ta
526 switch (fcp
->fc_pri_ta
& FCP_PTA_MASK
) {
528 task_attr
= MSG_HEAD_TAG
;
530 case FCP_PTA_ORDERED
:
531 task_attr
= MSG_ORDERED_TAG
;
534 task_attr
= MSG_ACA_TAG
;
536 case FCP_PTA_SIMPLE
: /* Fallthrough */
538 task_attr
= MSG_SIMPLE_TAG
;
541 fc_seq_exch(cmd
->seq
)->lp
->tt
.seq_set_resp(cmd
->seq
, ft_recv_seq
, cmd
);
543 * Use a single se_cmd->cmd_kref as we expect to release se_cmd
544 * directly from ft_check_stop_free callback in response path.
546 if (target_submit_cmd(&cmd
->se_cmd
, cmd
->sess
->se_sess
, fcp
->fc_cdb
,
547 &cmd
->ft_sense_buffer
[0], scsilun_to_int(&fcp
->fc_lun
),
548 ntohl(fcp
->fc_dl
), task_attr
, data_dir
, 0))
551 pr_debug("r_ctl %x alloc target_submit_cmd\n", fh
->fh_r_ctl
);
555 ft_send_resp_code_and_free(cmd
, FCP_CMND_FIELDS_INVALID
);