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 <linux/version.h> 23 #include <generated/utsrelease.h> 24 #include <linux/utsname.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/kthread.h> 28 #include <linux/types.h> 29 #include <linux/string.h> 30 #include <linux/configfs.h> 31 #include <linux/ctype.h> 32 #include <linux/hash.h> 33 #include <asm/unaligned.h> 34 #include <scsi/scsi.h> 35 #include <scsi/scsi_host.h> 36 #include <scsi/scsi_device.h> 37 #include <scsi/scsi_cmnd.h> 38 #include <scsi/scsi_tcq.h> 39 #include <scsi/libfc.h> 40 #include <scsi/fc_encode.h> 41 42 #include <target/target_core_base.h> 43 #include <target/target_core_transport.h> 44 #include <target/target_core_fabric_ops.h> 45 #include <target/target_core_device.h> 46 #include <target/target_core_tpg.h> 47 #include <target/target_core_configfs.h> 48 #include <target/target_core_base.h> 49 #include <target/target_core_tmr.h> 50 #include <target/configfs_macros.h> 51 52 #include "tcm_fc.h" 53 54 /* 55 * Dump cmd state for debugging. 56 */ 57 void ft_dump_cmd(struct ft_cmd *cmd, const char *caller) 58 { 59 struct fc_exch *ep; 60 struct fc_seq *sp; 61 struct se_cmd *se_cmd; 62 struct se_mem *mem; 63 struct se_transport_task *task; 64 65 if (!(ft_debug_logging & FT_DEBUG_IO)) 66 return; 67 68 se_cmd = &cmd->se_cmd; 69 printk(KERN_INFO "%s: cmd %p state %d sess %p seq %p se_cmd %p\n", 70 caller, cmd, cmd->state, cmd->sess, cmd->seq, se_cmd); 71 printk(KERN_INFO "%s: cmd %p cdb %p\n", 72 caller, cmd, cmd->cdb); 73 printk(KERN_INFO "%s: cmd %p lun %d\n", caller, cmd, cmd->lun); 74 75 task = T_TASK(se_cmd); 76 printk(KERN_INFO "%s: cmd %p task %p se_num %u buf %p len %u se_cmd_flags <0x%x>\n", 77 caller, cmd, task, task->t_tasks_se_num, 78 task->t_task_buf, se_cmd->data_length, se_cmd->se_cmd_flags); 79 if (task->t_mem_list) 80 list_for_each_entry(mem, task->t_mem_list, se_list) 81 printk(KERN_INFO "%s: cmd %p mem %p page %p " 82 "len 0x%x off 0x%x\n", 83 caller, cmd, mem, 84 mem->se_page, mem->se_len, mem->se_off); 85 sp = cmd->seq; 86 if (sp) { 87 ep = fc_seq_exch(sp); 88 printk(KERN_INFO "%s: cmd %p sid %x did %x " 89 "ox_id %x rx_id %x seq_id %x e_stat %x\n", 90 caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid, 91 sp->id, ep->esb_stat); 92 } 93 print_hex_dump(KERN_INFO, "ft_dump_cmd ", DUMP_PREFIX_NONE, 94 16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0); 95 } 96 97 /* 98 * Get LUN from CDB. 99 */ 100 static int ft_get_lun_for_cmd(struct ft_cmd *cmd, u8 *lunp) 101 { 102 u64 lun; 103 104 lun = lunp[1]; 105 switch (lunp[0] >> 6) { 106 case 0: 107 break; 108 case 1: 109 lun |= (lunp[0] & 0x3f) << 8; 110 break; 111 default: 112 return -1; 113 } 114 if (lun >= TRANSPORT_MAX_LUNS_PER_TPG) 115 return -1; 116 cmd->lun = lun; 117 return transport_get_lun_for_cmd(&cmd->se_cmd, NULL, lun); 118 } 119 120 static void ft_queue_cmd(struct ft_sess *sess, struct ft_cmd *cmd) 121 { 122 struct se_queue_obj *qobj; 123 unsigned long flags; 124 125 qobj = &sess->tport->tpg->qobj; 126 spin_lock_irqsave(&qobj->cmd_queue_lock, flags); 127 list_add_tail(&cmd->se_req.qr_list, &qobj->qobj_list); 128 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); 129 atomic_inc(&qobj->queue_cnt); 130 wake_up_interruptible(&qobj->thread_wq); 131 } 132 133 static struct ft_cmd *ft_dequeue_cmd(struct se_queue_obj *qobj) 134 { 135 unsigned long flags; 136 struct se_queue_req *qr; 137 138 spin_lock_irqsave(&qobj->cmd_queue_lock, flags); 139 if (list_empty(&qobj->qobj_list)) { 140 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); 141 return NULL; 142 } 143 qr = list_first_entry(&qobj->qobj_list, struct se_queue_req, qr_list); 144 list_del(&qr->qr_list); 145 atomic_dec(&qobj->queue_cnt); 146 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); 147 return container_of(qr, struct ft_cmd, se_req); 148 } 149 150 static void ft_free_cmd(struct ft_cmd *cmd) 151 { 152 struct fc_frame *fp; 153 struct fc_lport *lport; 154 155 if (!cmd) 156 return; 157 fp = cmd->req_frame; 158 lport = fr_dev(fp); 159 if (fr_seq(fp)) 160 lport->tt.seq_release(fr_seq(fp)); 161 fc_frame_free(fp); 162 ft_sess_put(cmd->sess); /* undo get from lookup at recv */ 163 kfree(cmd); 164 } 165 166 void ft_release_cmd(struct se_cmd *se_cmd) 167 { 168 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 169 170 ft_free_cmd(cmd); 171 } 172 173 void ft_check_stop_free(struct se_cmd *se_cmd) 174 { 175 transport_generic_free_cmd(se_cmd, 0, 1, 0); 176 } 177 178 /* 179 * Send response. 180 */ 181 int ft_queue_status(struct se_cmd *se_cmd) 182 { 183 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 184 struct fc_frame *fp; 185 struct fcp_resp_with_ext *fcp; 186 struct fc_lport *lport; 187 struct fc_exch *ep; 188 size_t len; 189 190 ft_dump_cmd(cmd, __func__); 191 ep = fc_seq_exch(cmd->seq); 192 lport = ep->lp; 193 len = sizeof(*fcp) + se_cmd->scsi_sense_length; 194 fp = fc_frame_alloc(lport, len); 195 if (!fp) { 196 /* XXX shouldn't just drop it - requeue and retry? */ 197 return 0; 198 } 199 fcp = fc_frame_payload_get(fp, len); 200 memset(fcp, 0, len); 201 fcp->resp.fr_status = se_cmd->scsi_status; 202 203 len = se_cmd->scsi_sense_length; 204 if (len) { 205 fcp->resp.fr_flags |= FCP_SNS_LEN_VAL; 206 fcp->ext.fr_sns_len = htonl(len); 207 memcpy((fcp + 1), se_cmd->sense_buffer, len); 208 } 209 210 /* 211 * Test underflow and overflow with one mask. Usually both are off. 212 * Bidirectional commands are not handled yet. 213 */ 214 if (se_cmd->se_cmd_flags & (SCF_OVERFLOW_BIT | SCF_UNDERFLOW_BIT)) { 215 if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) 216 fcp->resp.fr_flags |= FCP_RESID_OVER; 217 else 218 fcp->resp.fr_flags |= FCP_RESID_UNDER; 219 fcp->ext.fr_resid = cpu_to_be32(se_cmd->residual_count); 220 } 221 222 /* 223 * Send response. 224 */ 225 cmd->seq = lport->tt.seq_start_next(cmd->seq); 226 fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP, 227 FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0); 228 229 lport->tt.seq_send(lport, cmd->seq, fp); 230 lport->tt.exch_done(cmd->seq); 231 return 0; 232 } 233 234 int ft_write_pending_status(struct se_cmd *se_cmd) 235 { 236 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 237 238 return cmd->write_data_len != se_cmd->data_length; 239 } 240 241 /* 242 * Send TX_RDY (transfer ready). 243 */ 244 int ft_write_pending(struct se_cmd *se_cmd) 245 { 246 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 247 struct fc_frame *fp; 248 struct fcp_txrdy *txrdy; 249 struct fc_lport *lport; 250 struct fc_exch *ep; 251 struct fc_frame_header *fh; 252 u32 f_ctl; 253 254 ft_dump_cmd(cmd, __func__); 255 256 ep = fc_seq_exch(cmd->seq); 257 lport = ep->lp; 258 fp = fc_frame_alloc(lport, sizeof(*txrdy)); 259 if (!fp) 260 return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES; 261 262 txrdy = fc_frame_payload_get(fp, sizeof(*txrdy)); 263 memset(txrdy, 0, sizeof(*txrdy)); 264 txrdy->ft_burst_len = htonl(se_cmd->data_length); 265 266 cmd->seq = lport->tt.seq_start_next(cmd->seq); 267 fc_fill_fc_hdr(fp, FC_RCTL_DD_DATA_DESC, ep->did, ep->sid, FC_TYPE_FCP, 268 FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 269 270 fh = fc_frame_header_get(fp); 271 f_ctl = ntoh24(fh->fh_f_ctl); 272 273 /* Only if it is 'Exchange Responder' */ 274 if (f_ctl & FC_FC_EX_CTX) { 275 /* Target is 'exchange responder' and sending XFER_READY 276 * to 'exchange initiator (initiator)' 277 */ 278 if ((ep->xid <= lport->lro_xid) && 279 (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) { 280 if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) { 281 /* 282 * Map se_mem list to scatterlist, so that 283 * DDP can be setup. DDP setup function require 284 * scatterlist. se_mem_list is internal to 285 * TCM/LIO target 286 */ 287 transport_do_task_sg_chain(se_cmd); 288 cmd->sg = T_TASK(se_cmd)->t_tasks_sg_chained; 289 cmd->sg_cnt = 290 T_TASK(se_cmd)->t_tasks_sg_chained_no; 291 } 292 if (cmd->sg && lport->tt.ddp_setup(lport, ep->xid, 293 cmd->sg, cmd->sg_cnt)) 294 cmd->was_ddp_setup = 1; 295 } 296 } 297 lport->tt.seq_send(lport, cmd->seq, fp); 298 return 0; 299 } 300 301 u32 ft_get_task_tag(struct se_cmd *se_cmd) 302 { 303 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 304 305 return fc_seq_exch(cmd->seq)->rxid; 306 } 307 308 int ft_get_cmd_state(struct se_cmd *se_cmd) 309 { 310 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 311 312 return cmd->state; 313 } 314 315 int ft_is_state_remove(struct se_cmd *se_cmd) 316 { 317 return 0; /* XXX TBD */ 318 } 319 320 void ft_new_cmd_failure(struct se_cmd *se_cmd) 321 { 322 /* XXX TBD */ 323 printk(KERN_INFO "%s: se_cmd %p\n", __func__, se_cmd); 324 } 325 326 /* 327 * FC sequence response handler for follow-on sequences (data) and aborts. 328 */ 329 static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg) 330 { 331 struct ft_cmd *cmd = arg; 332 struct fc_frame_header *fh; 333 334 if (IS_ERR(fp)) { 335 /* XXX need to find cmd if queued */ 336 cmd->se_cmd.t_state = TRANSPORT_REMOVE; 337 cmd->seq = NULL; 338 transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0); 339 return; 340 } 341 342 fh = fc_frame_header_get(fp); 343 344 switch (fh->fh_r_ctl) { 345 case FC_RCTL_DD_SOL_DATA: /* write data */ 346 ft_recv_write_data(cmd, fp); 347 break; 348 case FC_RCTL_DD_UNSOL_CTL: /* command */ 349 case FC_RCTL_DD_SOL_CTL: /* transfer ready */ 350 case FC_RCTL_DD_DATA_DESC: /* transfer ready */ 351 default: 352 printk(KERN_INFO "%s: unhandled frame r_ctl %x\n", 353 __func__, fh->fh_r_ctl); 354 fc_frame_free(fp); 355 transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0); 356 break; 357 } 358 } 359 360 /* 361 * Send a FCP response including SCSI status and optional FCP rsp_code. 362 * status is SAM_STAT_GOOD (zero) iff code is valid. 363 * This is used in error cases, such as allocation failures. 364 */ 365 static void ft_send_resp_status(struct fc_lport *lport, 366 const struct fc_frame *rx_fp, 367 u32 status, enum fcp_resp_rsp_codes code) 368 { 369 struct fc_frame *fp; 370 struct fc_seq *sp; 371 const struct fc_frame_header *fh; 372 size_t len; 373 struct fcp_resp_with_ext *fcp; 374 struct fcp_resp_rsp_info *info; 375 376 fh = fc_frame_header_get(rx_fp); 377 FT_IO_DBG("FCP error response: did %x oxid %x status %x code %x\n", 378 ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code); 379 len = sizeof(*fcp); 380 if (status == SAM_STAT_GOOD) 381 len += sizeof(*info); 382 fp = fc_frame_alloc(lport, len); 383 if (!fp) 384 return; 385 fcp = fc_frame_payload_get(fp, len); 386 memset(fcp, 0, len); 387 fcp->resp.fr_status = status; 388 if (status == SAM_STAT_GOOD) { 389 fcp->ext.fr_rsp_len = htonl(sizeof(*info)); 390 fcp->resp.fr_flags |= FCP_RSP_LEN_VAL; 391 info = (struct fcp_resp_rsp_info *)(fcp + 1); 392 info->rsp_code = code; 393 } 394 395 fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0); 396 sp = fr_seq(fp); 397 if (sp) 398 lport->tt.seq_send(lport, sp, fp); 399 else 400 lport->tt.frame_send(lport, fp); 401 } 402 403 /* 404 * Send error or task management response. 405 * Always frees the cmd and associated state. 406 */ 407 static void ft_send_resp_code(struct ft_cmd *cmd, enum fcp_resp_rsp_codes code) 408 { 409 ft_send_resp_status(cmd->sess->tport->lport, 410 cmd->req_frame, SAM_STAT_GOOD, code); 411 ft_free_cmd(cmd); 412 } 413 414 /* 415 * Handle Task Management Request. 416 */ 417 static void ft_send_tm(struct ft_cmd *cmd) 418 { 419 struct se_tmr_req *tmr; 420 struct fcp_cmnd *fcp; 421 u8 tm_func; 422 423 fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp)); 424 425 switch (fcp->fc_tm_flags) { 426 case FCP_TMF_LUN_RESET: 427 tm_func = TMR_LUN_RESET; 428 if (ft_get_lun_for_cmd(cmd, fcp->fc_lun) < 0) { 429 ft_dump_cmd(cmd, __func__); 430 transport_send_check_condition_and_sense(&cmd->se_cmd, 431 cmd->se_cmd.scsi_sense_reason, 0); 432 ft_sess_put(cmd->sess); 433 return; 434 } 435 break; 436 case FCP_TMF_TGT_RESET: 437 tm_func = TMR_TARGET_WARM_RESET; 438 break; 439 case FCP_TMF_CLR_TASK_SET: 440 tm_func = TMR_CLEAR_TASK_SET; 441 break; 442 case FCP_TMF_ABT_TASK_SET: 443 tm_func = TMR_ABORT_TASK_SET; 444 break; 445 case FCP_TMF_CLR_ACA: 446 tm_func = TMR_CLEAR_ACA; 447 break; 448 default: 449 /* 450 * FCP4r01 indicates having a combination of 451 * tm_flags set is invalid. 452 */ 453 FT_TM_DBG("invalid FCP tm_flags %x\n", fcp->fc_tm_flags); 454 ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID); 455 return; 456 } 457 458 FT_TM_DBG("alloc tm cmd fn %d\n", tm_func); 459 tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func); 460 if (!tmr) { 461 FT_TM_DBG("alloc failed\n"); 462 ft_send_resp_code(cmd, FCP_TMF_FAILED); 463 return; 464 } 465 cmd->se_cmd.se_tmr_req = tmr; 466 transport_generic_handle_tmr(&cmd->se_cmd); 467 } 468 469 /* 470 * Send status from completed task management request. 471 */ 472 int ft_queue_tm_resp(struct se_cmd *se_cmd) 473 { 474 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 475 struct se_tmr_req *tmr = se_cmd->se_tmr_req; 476 enum fcp_resp_rsp_codes code; 477 478 switch (tmr->response) { 479 case TMR_FUNCTION_COMPLETE: 480 code = FCP_TMF_CMPL; 481 break; 482 case TMR_LUN_DOES_NOT_EXIST: 483 code = FCP_TMF_INVALID_LUN; 484 break; 485 case TMR_FUNCTION_REJECTED: 486 code = FCP_TMF_REJECTED; 487 break; 488 case TMR_TASK_DOES_NOT_EXIST: 489 case TMR_TASK_STILL_ALLEGIANT: 490 case TMR_TASK_FAILOVER_NOT_SUPPORTED: 491 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 492 case TMR_FUNCTION_AUTHORIZATION_FAILED: 493 default: 494 code = FCP_TMF_FAILED; 495 break; 496 } 497 FT_TM_DBG("tmr fn %d resp %d fcp code %d\n", 498 tmr->function, tmr->response, code); 499 ft_send_resp_code(cmd, code); 500 return 0; 501 } 502 503 /* 504 * Handle incoming FCP command. 505 */ 506 static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) 507 { 508 struct ft_cmd *cmd; 509 struct fc_lport *lport = sess->tport->lport; 510 511 cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC); 512 if (!cmd) 513 goto busy; 514 cmd->sess = sess; 515 cmd->seq = lport->tt.seq_assign(lport, fp); 516 if (!cmd->seq) { 517 kfree(cmd); 518 goto busy; 519 } 520 cmd->req_frame = fp; /* hold frame during cmd */ 521 ft_queue_cmd(sess, cmd); 522 return; 523 524 busy: 525 FT_IO_DBG("cmd or seq allocation failure - sending BUSY\n"); 526 ft_send_resp_status(lport, fp, SAM_STAT_BUSY, 0); 527 fc_frame_free(fp); 528 ft_sess_put(sess); /* undo get from lookup */ 529 } 530 531 532 /* 533 * Handle incoming FCP frame. 534 * Caller has verified that the frame is type FCP. 535 */ 536 void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp) 537 { 538 struct fc_frame_header *fh = fc_frame_header_get(fp); 539 540 switch (fh->fh_r_ctl) { 541 case FC_RCTL_DD_UNSOL_CMD: /* command */ 542 ft_recv_cmd(sess, fp); 543 break; 544 case FC_RCTL_DD_SOL_DATA: /* write data */ 545 case FC_RCTL_DD_UNSOL_CTL: 546 case FC_RCTL_DD_SOL_CTL: 547 case FC_RCTL_DD_DATA_DESC: /* transfer ready */ 548 case FC_RCTL_ELS4_REQ: /* SRR, perhaps */ 549 default: 550 printk(KERN_INFO "%s: unhandled frame r_ctl %x\n", 551 __func__, fh->fh_r_ctl); 552 fc_frame_free(fp); 553 ft_sess_put(sess); /* undo get from lookup */ 554 break; 555 } 556 } 557 558 /* 559 * Send new command to target. 560 */ 561 static void ft_send_cmd(struct ft_cmd *cmd) 562 { 563 struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame); 564 struct se_cmd *se_cmd; 565 struct fcp_cmnd *fcp; 566 int data_dir; 567 u32 data_len; 568 int task_attr; 569 int ret; 570 571 fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp)); 572 if (!fcp) 573 goto err; 574 575 if (fcp->fc_flags & FCP_CFL_LEN_MASK) 576 goto err; /* not handling longer CDBs yet */ 577 578 if (fcp->fc_tm_flags) { 579 task_attr = FCP_PTA_SIMPLE; 580 data_dir = DMA_NONE; 581 data_len = 0; 582 } else { 583 switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) { 584 case 0: 585 data_dir = DMA_NONE; 586 break; 587 case FCP_CFL_RDDATA: 588 data_dir = DMA_FROM_DEVICE; 589 break; 590 case FCP_CFL_WRDATA: 591 data_dir = DMA_TO_DEVICE; 592 break; 593 case FCP_CFL_WRDATA | FCP_CFL_RDDATA: 594 goto err; /* TBD not supported by tcm_fc yet */ 595 } 596 /* 597 * Locate the SAM Task Attr from fc_pri_ta 598 */ 599 switch (fcp->fc_pri_ta & FCP_PTA_MASK) { 600 case FCP_PTA_HEADQ: 601 task_attr = MSG_HEAD_TAG; 602 break; 603 case FCP_PTA_ORDERED: 604 task_attr = MSG_ORDERED_TAG; 605 break; 606 case FCP_PTA_ACA: 607 task_attr = MSG_ACA_TAG; 608 break; 609 case FCP_PTA_SIMPLE: /* Fallthrough */ 610 default: 611 task_attr = MSG_SIMPLE_TAG; 612 } 613 614 615 task_attr = fcp->fc_pri_ta & FCP_PTA_MASK; 616 data_len = ntohl(fcp->fc_dl); 617 cmd->cdb = fcp->fc_cdb; 618 } 619 620 se_cmd = &cmd->se_cmd; 621 /* 622 * Initialize struct se_cmd descriptor from target_core_mod 623 * infrastructure 624 */ 625 transport_init_se_cmd(se_cmd, &ft_configfs->tf_ops, cmd->sess->se_sess, 626 data_len, data_dir, task_attr, 627 &cmd->ft_sense_buffer[0]); 628 /* 629 * Check for FCP task management flags 630 */ 631 if (fcp->fc_tm_flags) { 632 ft_send_tm(cmd); 633 return; 634 } 635 636 fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd); 637 638 ret = ft_get_lun_for_cmd(cmd, fcp->fc_lun); 639 if (ret < 0) { 640 ft_dump_cmd(cmd, __func__); 641 transport_send_check_condition_and_sense(&cmd->se_cmd, 642 cmd->se_cmd.scsi_sense_reason, 0); 643 return; 644 } 645 646 ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb); 647 648 FT_IO_DBG("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret); 649 ft_dump_cmd(cmd, __func__); 650 651 if (ret == -1) { 652 transport_send_check_condition_and_sense(se_cmd, 653 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); 654 transport_generic_free_cmd(se_cmd, 0, 1, 0); 655 return; 656 } 657 if (ret == -2) { 658 if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT) 659 ft_queue_status(se_cmd); 660 else 661 transport_send_check_condition_and_sense(se_cmd, 662 se_cmd->scsi_sense_reason, 0); 663 transport_generic_free_cmd(se_cmd, 0, 1, 0); 664 return; 665 } 666 transport_generic_handle_cdb(se_cmd); 667 return; 668 669 err: 670 ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID); 671 return; 672 } 673 674 /* 675 * Handle request in the command thread. 676 */ 677 static void ft_exec_req(struct ft_cmd *cmd) 678 { 679 FT_IO_DBG("cmd state %x\n", cmd->state); 680 switch (cmd->state) { 681 case FC_CMD_ST_NEW: 682 ft_send_cmd(cmd); 683 break; 684 default: 685 break; 686 } 687 } 688 689 /* 690 * Processing thread. 691 * Currently one thread per tpg. 692 */ 693 int ft_thread(void *arg) 694 { 695 struct ft_tpg *tpg = arg; 696 struct se_queue_obj *qobj = &tpg->qobj; 697 struct ft_cmd *cmd; 698 int ret; 699 700 set_user_nice(current, -20); 701 702 while (!kthread_should_stop()) { 703 ret = wait_event_interruptible(qobj->thread_wq, 704 atomic_read(&qobj->queue_cnt) || kthread_should_stop()); 705 if (ret < 0 || kthread_should_stop()) 706 goto out; 707 cmd = ft_dequeue_cmd(qobj); 708 if (cmd) 709 ft_exec_req(cmd); 710 } 711 712 out: 713 return 0; 714 } 715