1 /* 2 * Copyright (c) 2010 Cisco Systems, Inc. 3 * 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. 7 * 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 11 * more details. 12 * 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. 16 */ 17 18 /* XXX TBD some includes may be extraneous */ 19 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> 40 41 #include <target/target_core_base.h> 42 #include <target/target_core_transport.h> 43 #include <target/target_core_fabric_ops.h> 44 #include <target/target_core_device.h> 45 #include <target/target_core_tpg.h> 46 #include <target/target_core_configfs.h> 47 #include <target/target_core_tmr.h> 48 #include <target/configfs_macros.h> 49 50 #include "tcm_fc.h" 51 52 /* 53 * Dump cmd state for debugging. 54 */ 55 void ft_dump_cmd(struct ft_cmd *cmd, const char *caller) 56 { 57 struct fc_exch *ep; 58 struct fc_seq *sp; 59 struct se_cmd *se_cmd; 60 struct scatterlist *sg; 61 int count; 62 63 se_cmd = &cmd->se_cmd; 64 pr_debug("%s: cmd %p sess %p seq %p se_cmd %p\n", 65 caller, cmd, cmd->sess, cmd->seq, se_cmd); 66 pr_debug("%s: cmd %p cdb %p\n", 67 caller, cmd, cmd->cdb); 68 pr_debug("%s: cmd %p lun %d\n", caller, cmd, cmd->lun); 69 70 pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n", 71 caller, cmd, se_cmd->t_data_nents, 72 se_cmd->data_length, se_cmd->se_cmd_flags); 73 74 for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, count) 75 pr_debug("%s: cmd %p sg %p page %p " 76 "len 0x%x off 0x%x\n", 77 caller, cmd, sg, 78 sg_page(sg), sg->length, sg->offset); 79 80 sp = cmd->seq; 81 if (sp) { 82 ep = fc_seq_exch(sp); 83 pr_debug("%s: cmd %p sid %x did %x " 84 "ox_id %x rx_id %x seq_id %x e_stat %x\n", 85 caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid, 86 sp->id, ep->esb_stat); 87 } 88 print_hex_dump(KERN_INFO, "ft_dump_cmd ", DUMP_PREFIX_NONE, 89 16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0); 90 } 91 92 static void ft_free_cmd(struct ft_cmd *cmd) 93 { 94 struct fc_frame *fp; 95 struct fc_lport *lport; 96 97 if (!cmd) 98 return; 99 fp = cmd->req_frame; 100 lport = fr_dev(fp); 101 if (fr_seq(fp)) 102 lport->tt.seq_release(fr_seq(fp)); 103 fc_frame_free(fp); 104 ft_sess_put(cmd->sess); /* undo get from lookup at recv */ 105 kfree(cmd); 106 } 107 108 void ft_release_cmd(struct se_cmd *se_cmd) 109 { 110 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 111 112 ft_free_cmd(cmd); 113 } 114 115 void ft_check_stop_free(struct se_cmd *se_cmd) 116 { 117 transport_generic_free_cmd(se_cmd, 0); 118 } 119 120 /* 121 * Send response. 122 */ 123 int ft_queue_status(struct se_cmd *se_cmd) 124 { 125 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 126 struct fc_frame *fp; 127 struct fcp_resp_with_ext *fcp; 128 struct fc_lport *lport; 129 struct fc_exch *ep; 130 size_t len; 131 132 ft_dump_cmd(cmd, __func__); 133 ep = fc_seq_exch(cmd->seq); 134 lport = ep->lp; 135 len = sizeof(*fcp) + se_cmd->scsi_sense_length; 136 fp = fc_frame_alloc(lport, len); 137 if (!fp) { 138 /* XXX shouldn't just drop it - requeue and retry? */ 139 return 0; 140 } 141 fcp = fc_frame_payload_get(fp, len); 142 memset(fcp, 0, len); 143 fcp->resp.fr_status = se_cmd->scsi_status; 144 145 len = se_cmd->scsi_sense_length; 146 if (len) { 147 fcp->resp.fr_flags |= FCP_SNS_LEN_VAL; 148 fcp->ext.fr_sns_len = htonl(len); 149 memcpy((fcp + 1), se_cmd->sense_buffer, len); 150 } 151 152 /* 153 * Test underflow and overflow with one mask. Usually both are off. 154 * Bidirectional commands are not handled yet. 155 */ 156 if (se_cmd->se_cmd_flags & (SCF_OVERFLOW_BIT | SCF_UNDERFLOW_BIT)) { 157 if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) 158 fcp->resp.fr_flags |= FCP_RESID_OVER; 159 else 160 fcp->resp.fr_flags |= FCP_RESID_UNDER; 161 fcp->ext.fr_resid = cpu_to_be32(se_cmd->residual_count); 162 } 163 164 /* 165 * Send response. 166 */ 167 cmd->seq = lport->tt.seq_start_next(cmd->seq); 168 fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP, 169 FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0); 170 171 lport->tt.seq_send(lport, cmd->seq, fp); 172 lport->tt.exch_done(cmd->seq); 173 return 0; 174 } 175 176 int ft_write_pending_status(struct se_cmd *se_cmd) 177 { 178 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 179 180 return cmd->write_data_len != se_cmd->data_length; 181 } 182 183 /* 184 * Send TX_RDY (transfer ready). 185 */ 186 int ft_write_pending(struct se_cmd *se_cmd) 187 { 188 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 189 struct fc_frame *fp; 190 struct fcp_txrdy *txrdy; 191 struct fc_lport *lport; 192 struct fc_exch *ep; 193 struct fc_frame_header *fh; 194 u32 f_ctl; 195 196 ft_dump_cmd(cmd, __func__); 197 198 ep = fc_seq_exch(cmd->seq); 199 lport = ep->lp; 200 fp = fc_frame_alloc(lport, sizeof(*txrdy)); 201 if (!fp) 202 return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES; 203 204 txrdy = fc_frame_payload_get(fp, sizeof(*txrdy)); 205 memset(txrdy, 0, sizeof(*txrdy)); 206 txrdy->ft_burst_len = htonl(se_cmd->data_length); 207 208 cmd->seq = lport->tt.seq_start_next(cmd->seq); 209 fc_fill_fc_hdr(fp, FC_RCTL_DD_DATA_DESC, ep->did, ep->sid, FC_TYPE_FCP, 210 FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 211 212 fh = fc_frame_header_get(fp); 213 f_ctl = ntoh24(fh->fh_f_ctl); 214 215 /* Only if it is 'Exchange Responder' */ 216 if (f_ctl & FC_FC_EX_CTX) { 217 /* Target is 'exchange responder' and sending XFER_READY 218 * to 'exchange initiator (initiator)' 219 */ 220 if ((ep->xid <= lport->lro_xid) && 221 (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) { 222 if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) { 223 /* 224 * cmd may have been broken up into multiple 225 * tasks. Link their sgs together so we can 226 * operate on them all at once. 227 */ 228 transport_do_task_sg_chain(se_cmd); 229 cmd->sg = se_cmd->t_tasks_sg_chained; 230 cmd->sg_cnt = 231 se_cmd->t_tasks_sg_chained_no; 232 } 233 if (cmd->sg && lport->tt.ddp_target(lport, ep->xid, 234 cmd->sg, 235 cmd->sg_cnt)) 236 cmd->was_ddp_setup = 1; 237 } 238 } 239 lport->tt.seq_send(lport, cmd->seq, fp); 240 return 0; 241 } 242 243 u32 ft_get_task_tag(struct se_cmd *se_cmd) 244 { 245 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 246 247 return fc_seq_exch(cmd->seq)->rxid; 248 } 249 250 int ft_get_cmd_state(struct se_cmd *se_cmd) 251 { 252 return 0; 253 } 254 255 int ft_is_state_remove(struct se_cmd *se_cmd) 256 { 257 return 0; /* XXX TBD */ 258 } 259 260 /* 261 * FC sequence response handler for follow-on sequences (data) and aborts. 262 */ 263 static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg) 264 { 265 struct ft_cmd *cmd = arg; 266 struct fc_frame_header *fh; 267 268 if (IS_ERR(fp)) { 269 /* XXX need to find cmd if queued */ 270 cmd->seq = NULL; 271 transport_generic_free_cmd(&cmd->se_cmd, 0); 272 return; 273 } 274 275 fh = fc_frame_header_get(fp); 276 277 switch (fh->fh_r_ctl) { 278 case FC_RCTL_DD_SOL_DATA: /* write data */ 279 ft_recv_write_data(cmd, fp); 280 break; 281 case FC_RCTL_DD_UNSOL_CTL: /* command */ 282 case FC_RCTL_DD_SOL_CTL: /* transfer ready */ 283 case FC_RCTL_DD_DATA_DESC: /* transfer ready */ 284 default: 285 pr_debug("%s: unhandled frame r_ctl %x\n", 286 __func__, fh->fh_r_ctl); 287 ft_invl_hw_context(cmd); 288 fc_frame_free(fp); 289 transport_generic_free_cmd(&cmd->se_cmd, 0); 290 break; 291 } 292 } 293 294 /* 295 * Send a FCP response including SCSI status and optional FCP rsp_code. 296 * status is SAM_STAT_GOOD (zero) iff code is valid. 297 * This is used in error cases, such as allocation failures. 298 */ 299 static void ft_send_resp_status(struct fc_lport *lport, 300 const struct fc_frame *rx_fp, 301 u32 status, enum fcp_resp_rsp_codes code) 302 { 303 struct fc_frame *fp; 304 struct fc_seq *sp; 305 const struct fc_frame_header *fh; 306 size_t len; 307 struct fcp_resp_with_ext *fcp; 308 struct fcp_resp_rsp_info *info; 309 310 fh = fc_frame_header_get(rx_fp); 311 pr_debug("FCP error response: did %x oxid %x status %x code %x\n", 312 ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code); 313 len = sizeof(*fcp); 314 if (status == SAM_STAT_GOOD) 315 len += sizeof(*info); 316 fp = fc_frame_alloc(lport, len); 317 if (!fp) 318 return; 319 fcp = fc_frame_payload_get(fp, len); 320 memset(fcp, 0, len); 321 fcp->resp.fr_status = status; 322 if (status == SAM_STAT_GOOD) { 323 fcp->ext.fr_rsp_len = htonl(sizeof(*info)); 324 fcp->resp.fr_flags |= FCP_RSP_LEN_VAL; 325 info = (struct fcp_resp_rsp_info *)(fcp + 1); 326 info->rsp_code = code; 327 } 328 329 fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0); 330 sp = fr_seq(fp); 331 if (sp) 332 lport->tt.seq_send(lport, sp, fp); 333 else 334 lport->tt.frame_send(lport, fp); 335 } 336 337 /* 338 * Send error or task management response. 339 */ 340 static void ft_send_resp_code(struct ft_cmd *cmd, 341 enum fcp_resp_rsp_codes code) 342 { 343 ft_send_resp_status(cmd->sess->tport->lport, 344 cmd->req_frame, SAM_STAT_GOOD, code); 345 } 346 347 348 /* 349 * Send error or task management response. 350 * Always frees the cmd and associated state. 351 */ 352 static void ft_send_resp_code_and_free(struct ft_cmd *cmd, 353 enum fcp_resp_rsp_codes code) 354 { 355 ft_send_resp_code(cmd, code); 356 ft_free_cmd(cmd); 357 } 358 359 /* 360 * Handle Task Management Request. 361 */ 362 static void ft_send_tm(struct ft_cmd *cmd) 363 { 364 struct se_tmr_req *tmr; 365 struct fcp_cmnd *fcp; 366 struct ft_sess *sess; 367 u8 tm_func; 368 369 fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp)); 370 371 switch (fcp->fc_tm_flags) { 372 case FCP_TMF_LUN_RESET: 373 tm_func = TMR_LUN_RESET; 374 break; 375 case FCP_TMF_TGT_RESET: 376 tm_func = TMR_TARGET_WARM_RESET; 377 break; 378 case FCP_TMF_CLR_TASK_SET: 379 tm_func = TMR_CLEAR_TASK_SET; 380 break; 381 case FCP_TMF_ABT_TASK_SET: 382 tm_func = TMR_ABORT_TASK_SET; 383 break; 384 case FCP_TMF_CLR_ACA: 385 tm_func = TMR_CLEAR_ACA; 386 break; 387 default: 388 /* 389 * FCP4r01 indicates having a combination of 390 * tm_flags set is invalid. 391 */ 392 pr_debug("invalid FCP tm_flags %x\n", fcp->fc_tm_flags); 393 ft_send_resp_code_and_free(cmd, FCP_CMND_FIELDS_INVALID); 394 return; 395 } 396 397 pr_debug("alloc tm cmd fn %d\n", tm_func); 398 tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func, GFP_KERNEL); 399 if (!tmr) { 400 pr_debug("alloc failed\n"); 401 ft_send_resp_code_and_free(cmd, FCP_TMF_FAILED); 402 return; 403 } 404 cmd->se_cmd.se_tmr_req = tmr; 405 406 switch (fcp->fc_tm_flags) { 407 case FCP_TMF_LUN_RESET: 408 cmd->lun = scsilun_to_int((struct scsi_lun *)fcp->fc_lun); 409 if (transport_lookup_tmr_lun(&cmd->se_cmd, cmd->lun) < 0) { 410 /* 411 * Make sure to clean up newly allocated TMR request 412 * since "unable to handle TMR request because failed 413 * to get to LUN" 414 */ 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, cmd->lun); 418 ft_dump_cmd(cmd, __func__); 419 sess = cmd->sess; 420 transport_send_check_condition_and_sense(&cmd->se_cmd, 421 cmd->se_cmd.scsi_sense_reason, 0); 422 transport_generic_free_cmd(&cmd->se_cmd, 0); 423 ft_sess_put(sess); 424 return; 425 } 426 break; 427 case FCP_TMF_TGT_RESET: 428 case FCP_TMF_CLR_TASK_SET: 429 case FCP_TMF_ABT_TASK_SET: 430 case FCP_TMF_CLR_ACA: 431 break; 432 default: 433 return; 434 } 435 transport_generic_handle_tmr(&cmd->se_cmd); 436 } 437 438 /* 439 * Send status from completed task management request. 440 */ 441 int ft_queue_tm_resp(struct se_cmd *se_cmd) 442 { 443 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 444 struct se_tmr_req *tmr = se_cmd->se_tmr_req; 445 enum fcp_resp_rsp_codes code; 446 447 switch (tmr->response) { 448 case TMR_FUNCTION_COMPLETE: 449 code = FCP_TMF_CMPL; 450 break; 451 case TMR_LUN_DOES_NOT_EXIST: 452 code = FCP_TMF_INVALID_LUN; 453 break; 454 case TMR_FUNCTION_REJECTED: 455 code = FCP_TMF_REJECTED; 456 break; 457 case TMR_TASK_DOES_NOT_EXIST: 458 case TMR_TASK_STILL_ALLEGIANT: 459 case TMR_TASK_FAILOVER_NOT_SUPPORTED: 460 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 461 case TMR_FUNCTION_AUTHORIZATION_FAILED: 462 default: 463 code = FCP_TMF_FAILED; 464 break; 465 } 466 pr_debug("tmr fn %d resp %d fcp code %d\n", 467 tmr->function, tmr->response, code); 468 ft_send_resp_code(cmd, code); 469 return 0; 470 } 471 472 static void ft_send_work(struct work_struct *work); 473 474 /* 475 * Handle incoming FCP command. 476 */ 477 static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) 478 { 479 struct ft_cmd *cmd; 480 struct fc_lport *lport = sess->tport->lport; 481 482 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC); 483 if (!cmd) 484 goto busy; 485 cmd->sess = sess; 486 cmd->seq = lport->tt.seq_assign(lport, fp); 487 if (!cmd->seq) { 488 kfree(cmd); 489 goto busy; 490 } 491 cmd->req_frame = fp; /* hold frame during cmd */ 492 493 INIT_WORK(&cmd->work, ft_send_work); 494 queue_work(sess->tport->tpg->workqueue, &cmd->work); 495 return; 496 497 busy: 498 pr_debug("cmd or seq allocation failure - sending BUSY\n"); 499 ft_send_resp_status(lport, fp, SAM_STAT_BUSY, 0); 500 fc_frame_free(fp); 501 ft_sess_put(sess); /* undo get from lookup */ 502 } 503 504 505 /* 506 * Handle incoming FCP frame. 507 * Caller has verified that the frame is type FCP. 508 */ 509 void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp) 510 { 511 struct fc_frame_header *fh = fc_frame_header_get(fp); 512 513 switch (fh->fh_r_ctl) { 514 case FC_RCTL_DD_UNSOL_CMD: /* command */ 515 ft_recv_cmd(sess, fp); 516 break; 517 case FC_RCTL_DD_SOL_DATA: /* write data */ 518 case FC_RCTL_DD_UNSOL_CTL: 519 case FC_RCTL_DD_SOL_CTL: 520 case FC_RCTL_DD_DATA_DESC: /* transfer ready */ 521 case FC_RCTL_ELS4_REQ: /* SRR, perhaps */ 522 default: 523 pr_debug("%s: unhandled frame r_ctl %x\n", 524 __func__, fh->fh_r_ctl); 525 fc_frame_free(fp); 526 ft_sess_put(sess); /* undo get from lookup */ 527 break; 528 } 529 } 530 531 /* 532 * Send new command to target. 533 */ 534 static void ft_send_work(struct work_struct *work) 535 { 536 struct ft_cmd *cmd = container_of(work, struct ft_cmd, work); 537 struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame); 538 struct se_cmd *se_cmd; 539 struct fcp_cmnd *fcp; 540 int data_dir = 0; 541 u32 data_len; 542 int task_attr; 543 int ret; 544 545 fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp)); 546 if (!fcp) 547 goto err; 548 549 if (fcp->fc_flags & FCP_CFL_LEN_MASK) 550 goto err; /* not handling longer CDBs yet */ 551 552 if (fcp->fc_tm_flags) { 553 task_attr = FCP_PTA_SIMPLE; 554 data_dir = DMA_NONE; 555 data_len = 0; 556 } else { 557 switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) { 558 case 0: 559 data_dir = DMA_NONE; 560 break; 561 case FCP_CFL_RDDATA: 562 data_dir = DMA_FROM_DEVICE; 563 break; 564 case FCP_CFL_WRDATA: 565 data_dir = DMA_TO_DEVICE; 566 break; 567 case FCP_CFL_WRDATA | FCP_CFL_RDDATA: 568 goto err; /* TBD not supported by tcm_fc yet */ 569 } 570 /* 571 * Locate the SAM Task Attr from fc_pri_ta 572 */ 573 switch (fcp->fc_pri_ta & FCP_PTA_MASK) { 574 case FCP_PTA_HEADQ: 575 task_attr = MSG_HEAD_TAG; 576 break; 577 case FCP_PTA_ORDERED: 578 task_attr = MSG_ORDERED_TAG; 579 break; 580 case FCP_PTA_ACA: 581 task_attr = MSG_ACA_TAG; 582 break; 583 case FCP_PTA_SIMPLE: /* Fallthrough */ 584 default: 585 task_attr = MSG_SIMPLE_TAG; 586 } 587 588 589 task_attr = fcp->fc_pri_ta & FCP_PTA_MASK; 590 data_len = ntohl(fcp->fc_dl); 591 cmd->cdb = fcp->fc_cdb; 592 } 593 594 se_cmd = &cmd->se_cmd; 595 /* 596 * Initialize struct se_cmd descriptor from target_core_mod 597 * infrastructure 598 */ 599 transport_init_se_cmd(se_cmd, &ft_configfs->tf_ops, cmd->sess->se_sess, 600 data_len, data_dir, task_attr, 601 &cmd->ft_sense_buffer[0]); 602 /* 603 * Check for FCP task management flags 604 */ 605 if (fcp->fc_tm_flags) { 606 ft_send_tm(cmd); 607 return; 608 } 609 610 fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd); 611 612 cmd->lun = scsilun_to_int((struct scsi_lun *)fcp->fc_lun); 613 ret = transport_lookup_cmd_lun(&cmd->se_cmd, cmd->lun); 614 if (ret < 0) { 615 ft_dump_cmd(cmd, __func__); 616 transport_send_check_condition_and_sense(&cmd->se_cmd, 617 cmd->se_cmd.scsi_sense_reason, 0); 618 return; 619 } 620 621 ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb); 622 623 pr_debug("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret); 624 ft_dump_cmd(cmd, __func__); 625 626 if (ret == -ENOMEM) { 627 transport_send_check_condition_and_sense(se_cmd, 628 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); 629 transport_generic_free_cmd(se_cmd, 0); 630 return; 631 } 632 if (ret == -EINVAL) { 633 if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT) 634 ft_queue_status(se_cmd); 635 else 636 transport_send_check_condition_and_sense(se_cmd, 637 se_cmd->scsi_sense_reason, 0); 638 transport_generic_free_cmd(se_cmd, 0); 639 return; 640 } 641 transport_handle_cdb_direct(se_cmd); 642 return; 643 644 err: 645 ft_send_resp_code_and_free(cmd, FCP_CMND_FIELDS_INVALID); 646 } 647