Merge git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

+5 -5

drivers/scsi/qla2xxx/qla_init.c

··· 2204 2204 /* Clear outstanding commands array. */ 2205 2205 for (que = 0; que < ha->max_req_queues; que++) { 2206 2206 req = ha->req_q_map[que]; 2207 - if (!req) 2207 + if (!req || !test_bit(que, ha->req_qid_map)) 2208 2208 continue; 2209 2209 req->out_ptr = (void *)(req->ring + req->length); 2210 2210 *req->out_ptr = 0; ··· 2221 2221 2222 2222 for (que = 0; que < ha->max_rsp_queues; que++) { 2223 2223 rsp = ha->rsp_q_map[que]; 2224 - if (!rsp) 2224 + if (!rsp || !test_bit(que, ha->rsp_qid_map)) 2225 2225 continue; 2226 2226 rsp->in_ptr = (void *)(rsp->ring + rsp->length); 2227 2227 *rsp->in_ptr = 0; ··· 4981 4981 4982 4982 for (i = 1; i < ha->max_rsp_queues; i++) { 4983 4983 rsp = ha->rsp_q_map[i]; 4984 - if (rsp) { 4984 + if (rsp && test_bit(i, ha->rsp_qid_map)) { 4985 4985 rsp->options &= ~BIT_0; 4986 4986 ret = qla25xx_init_rsp_que(base_vha, rsp); 4987 4987 if (ret != QLA_SUCCESS) ··· 4996 4996 } 4997 4997 for (i = 1; i < ha->max_req_queues; i++) { 4998 4998 req = ha->req_q_map[i]; 4999 - if (req) { 5000 - /* Clear outstanding commands array. */ 4999 + if (req && test_bit(i, ha->req_qid_map)) { 5000 + /* Clear outstanding commands array. */ 5001 5001 req->options &= ~BIT_0; 5002 5002 ret = qla25xx_init_req_que(base_vha, req); 5003 5003 if (ret != QLA_SUCCESS)

+2 -2

drivers/scsi/qla2xxx/qla_isr.c

··· 3063 3063 "MSI-X: Failed to enable support " 3064 3064 "-- %d/%d\n Retry with %d vectors.\n", 3065 3065 ha->msix_count, ret, ret); 3066 + ha->msix_count = ret; 3067 + ha->max_rsp_queues = ha->msix_count - 1; 3066 3068 } 3067 - ha->msix_count = ret; 3068 - ha->max_rsp_queues = ha->msix_count - 1; 3069 3069 ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) * 3070 3070 ha->msix_count, GFP_KERNEL); 3071 3071 if (!ha->msix_entries) {

+2 -2

drivers/scsi/qla2xxx/qla_mid.c

··· 600 600 /* Delete request queues */ 601 601 for (cnt = 1; cnt < ha->max_req_queues; cnt++) { 602 602 req = ha->req_q_map[cnt]; 603 - if (req) { 603 + if (req && test_bit(cnt, ha->req_qid_map)) { 604 604 ret = qla25xx_delete_req_que(vha, req); 605 605 if (ret != QLA_SUCCESS) { 606 606 ql_log(ql_log_warn, vha, 0x00ea, ··· 614 614 /* Delete response queues */ 615 615 for (cnt = 1; cnt < ha->max_rsp_queues; cnt++) { 616 616 rsp = ha->rsp_q_map[cnt]; 617 - if (rsp) { 617 + if (rsp && test_bit(cnt, ha->rsp_qid_map)) { 618 618 ret = qla25xx_delete_rsp_que(vha, rsp); 619 619 if (ret != QLA_SUCCESS) { 620 620 ql_log(ql_log_warn, vha, 0x00eb,

+6

drivers/scsi/qla2xxx/qla_os.c

··· 409 409 int cnt; 410 410 411 411 for (cnt = 0; cnt < ha->max_req_queues; cnt++) { 412 + if (!test_bit(cnt, ha->req_qid_map)) 413 + continue; 414 + 412 415 req = ha->req_q_map[cnt]; 413 416 qla2x00_free_req_que(ha, req); 414 417 } ··· 419 416 ha->req_q_map = NULL; 420 417 421 418 for (cnt = 0; cnt < ha->max_rsp_queues; cnt++) { 419 + if (!test_bit(cnt, ha->rsp_qid_map)) 420 + continue; 421 + 422 422 rsp = ha->rsp_q_map[cnt]; 423 423 qla2x00_free_rsp_que(ha, rsp); 424 424 }

+45 -23

drivers/scsi/qla2xxx/qla_target.c

··· 105 105 static int qlt_issue_task_mgmt(struct qla_tgt_sess *sess, uint32_t lun, 106 106 int fn, void *iocb, int flags); 107 107 static void qlt_send_term_exchange(struct scsi_qla_host *ha, struct qla_tgt_cmd 108 - *cmd, struct atio_from_isp *atio, int ha_locked); 108 + *cmd, struct atio_from_isp *atio, int ha_locked, int ul_abort); 109 109 static void qlt_reject_free_srr_imm(struct scsi_qla_host *ha, 110 110 struct qla_tgt_srr_imm *imm, int ha_lock); 111 111 static void qlt_abort_cmd_on_host_reset(struct scsi_qla_host *vha, ··· 1756 1756 qlt_send_notify_ack(vha, &mcmd->orig_iocb.imm_ntfy, 1757 1757 0, 0, 0, 0, 0, 0); 1758 1758 else { 1759 - if (mcmd->se_cmd.se_tmr_req->function == TMR_ABORT_TASK) 1759 + if (mcmd->orig_iocb.atio.u.raw.entry_type == ABTS_RECV_24XX) 1760 1760 qlt_24xx_send_abts_resp(vha, &mcmd->orig_iocb.abts, 1761 1761 mcmd->fc_tm_rsp, false); 1762 1762 else ··· 2665 2665 /* no need to terminate. FW already freed exchange. */ 2666 2666 qlt_abort_cmd_on_host_reset(cmd->vha, cmd); 2667 2667 else 2668 - qlt_send_term_exchange(vha, cmd, &cmd->atio, 1); 2668 + qlt_send_term_exchange(vha, cmd, &cmd->atio, 1, 0); 2669 2669 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2670 2670 return 0; 2671 2671 } ··· 3173 3173 } 3174 3174 3175 3175 static void qlt_send_term_exchange(struct scsi_qla_host *vha, 3176 - struct qla_tgt_cmd *cmd, struct atio_from_isp *atio, int ha_locked) 3176 + struct qla_tgt_cmd *cmd, struct atio_from_isp *atio, int ha_locked, 3177 + int ul_abort) 3177 3178 { 3178 3179 unsigned long flags = 0; 3179 3180 int rc; ··· 3194 3193 qlt_alloc_qfull_cmd(vha, atio, 0, 0); 3195 3194 3196 3195 done: 3197 - if (cmd && (!cmd->aborted || 3198 - !cmd->cmd_sent_to_fw)) { 3196 + if (cmd && !ul_abort && !cmd->aborted) { 3199 3197 if (cmd->sg_mapped) 3200 3198 qlt_unmap_sg(vha, cmd); 3201 3199 vha->hw->tgt.tgt_ops->free_cmd(cmd); ··· 3253 3253 3254 3254 } 3255 3255 3256 - void qlt_abort_cmd(struct qla_tgt_cmd *cmd) 3256 + int qlt_abort_cmd(struct qla_tgt_cmd *cmd) 3257 3257 { 3258 3258 struct qla_tgt *tgt = cmd->tgt; 3259 3259 struct scsi_qla_host *vha = tgt->vha; 3260 3260 struct se_cmd *se_cmd = &cmd->se_cmd; 3261 + unsigned long flags; 3261 3262 3262 3263 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf014, 3263 3264 "qla_target(%d): terminating exchange for aborted cmd=%p " 3264 3265 "(se_cmd=%p, tag=%llu)", vha->vp_idx, cmd, &cmd->se_cmd, 3265 3266 se_cmd->tag); 3266 3267 3268 + spin_lock_irqsave(&cmd->cmd_lock, flags); 3269 + if (cmd->aborted) { 3270 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 3271 + /* 3272 + * It's normal to see 2 calls in this path: 3273 + * 1) XFER Rdy completion + CMD_T_ABORT 3274 + * 2) TCM TMR - drain_state_list 3275 + */ 3276 + ql_dbg(ql_dbg_tgt_mgt, vha, 0xffff, 3277 + "multiple abort. %p transport_state %x, t_state %x," 3278 + " se_cmd_flags %x \n", cmd, cmd->se_cmd.transport_state, 3279 + cmd->se_cmd.t_state,cmd->se_cmd.se_cmd_flags); 3280 + return EIO; 3281 + } 3267 3282 cmd->aborted = 1; 3268 3283 cmd->cmd_flags |= BIT_6; 3284 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 3269 3285 3270 - qlt_send_term_exchange(vha, cmd, &cmd->atio, 0); 3286 + qlt_send_term_exchange(vha, cmd, &cmd->atio, 0, 1); 3287 + return 0; 3271 3288 } 3272 3289 EXPORT_SYMBOL(qlt_abort_cmd); 3273 3290 ··· 3298 3281 be16_to_cpu(cmd->atio.u.isp24.fcp_hdr.ox_id)); 3299 3282 3300 3283 BUG_ON(cmd->cmd_in_wq); 3284 + 3285 + if (cmd->sg_mapped) 3286 + qlt_unmap_sg(cmd->vha, cmd); 3301 3287 3302 3288 if (!cmd->q_full) 3303 3289 qlt_decr_num_pend_cmds(cmd->vha); ··· 3419 3399 term = 1; 3420 3400 3421 3401 if (term) 3422 - qlt_send_term_exchange(vha, cmd, &cmd->atio, 1); 3402 + qlt_send_term_exchange(vha, cmd, &cmd->atio, 1, 0); 3423 3403 3424 3404 return term; 3425 3405 } ··· 3600 3580 case CTIO_PORT_LOGGED_OUT: 3601 3581 case CTIO_PORT_UNAVAILABLE: 3602 3582 { 3603 - int logged_out = (status & 0xFFFF); 3583 + int logged_out = 3584 + (status & 0xFFFF) == CTIO_PORT_LOGGED_OUT; 3585 + 3604 3586 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf059, 3605 3587 "qla_target(%d): CTIO with %s status %x " 3606 3588 "received (state %x, se_cmd %p)\n", vha->vp_idx, 3607 - (logged_out == CTIO_PORT_LOGGED_OUT) ? 3608 - "PORT LOGGED OUT" : "PORT UNAVAILABLE", 3589 + logged_out ? "PORT LOGGED OUT" : "PORT UNAVAILABLE", 3609 3590 status, cmd->state, se_cmd); 3610 3591 3611 3592 if (logged_out && cmd->sess) { ··· 3775 3754 goto out_term; 3776 3755 } 3777 3756 3757 + spin_lock_init(&cmd->cmd_lock); 3778 3758 cdb = &atio->u.isp24.fcp_cmnd.cdb[0]; 3779 3759 cmd->se_cmd.tag = atio->u.isp24.exchange_addr; 3780 3760 cmd->unpacked_lun = scsilun_to_int( ··· 3818 3796 */ 3819 3797 cmd->cmd_flags |= BIT_2; 3820 3798 spin_lock_irqsave(&ha->hardware_lock, flags); 3821 - qlt_send_term_exchange(vha, NULL, &cmd->atio, 1); 3799 + qlt_send_term_exchange(vha, NULL, &cmd->atio, 1, 0); 3822 3800 3823 3801 qlt_decr_num_pend_cmds(vha); 3824 3802 percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); ··· 3940 3918 3941 3919 out_term: 3942 3920 spin_lock_irqsave(&ha->hardware_lock, flags); 3943 - qlt_send_term_exchange(vha, NULL, &op->atio, 1); 3921 + qlt_send_term_exchange(vha, NULL, &op->atio, 1, 0); 3944 3922 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3945 3923 kfree(op); 3946 3924 ··· 4004 3982 4005 3983 cmd->cmd_in_wq = 1; 4006 3984 cmd->cmd_flags |= BIT_0; 4007 - cmd->se_cmd.cpuid = -1; 3985 + cmd->se_cmd.cpuid = ha->msix_count ? 3986 + ha->tgt.rspq_vector_cpuid : WORK_CPU_UNBOUND; 4008 3987 4009 3988 spin_lock(&vha->cmd_list_lock); 4010 3989 list_add_tail(&cmd->cmd_list, &vha->qla_cmd_list); ··· 4013 3990 4014 3991 INIT_WORK(&cmd->work, qlt_do_work); 4015 3992 if (ha->msix_count) { 4016 - cmd->se_cmd.cpuid = ha->tgt.rspq_vector_cpuid; 4017 3993 if (cmd->atio.u.isp24.fcp_cmnd.rddata) 4018 3994 queue_work_on(smp_processor_id(), qla_tgt_wq, 4019 3995 &cmd->work); ··· 4793 4771 dump_stack(); 4794 4772 } else { 4795 4773 cmd->cmd_flags |= BIT_9; 4796 - qlt_send_term_exchange(vha, cmd, &cmd->atio, 1); 4774 + qlt_send_term_exchange(vha, cmd, &cmd->atio, 1, 0); 4797 4775 } 4798 4776 spin_unlock_irqrestore(&ha->hardware_lock, flags); 4799 4777 } ··· 4972 4950 sctio, sctio->srr_id); 4973 4951 list_del(&sctio->srr_list_entry); 4974 4952 qlt_send_term_exchange(vha, sctio->cmd, 4975 - &sctio->cmd->atio, 1); 4953 + &sctio->cmd->atio, 1, 0); 4976 4954 kfree(sctio); 4977 4955 } 4978 4956 } ··· 5145 5123 atio->u.isp24.fcp_hdr.s_id); 5146 5124 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags); 5147 5125 if (!sess) { 5148 - qlt_send_term_exchange(vha, NULL, atio, 1); 5126 + qlt_send_term_exchange(vha, NULL, atio, 1, 0); 5149 5127 return 0; 5150 5128 } 5151 5129 /* Sending marker isn't necessary, since we called from ISR */ ··· 5428 5406 #if 1 /* With TERM EXCHANGE some FC cards refuse to boot */ 5429 5407 qlt_send_busy(vha, atio, SAM_STAT_BUSY); 5430 5408 #else 5431 - qlt_send_term_exchange(vha, NULL, atio, 1); 5409 + qlt_send_term_exchange(vha, NULL, atio, 1, 0); 5432 5410 #endif 5433 5411 5434 5412 if (!ha_locked) ··· 5545 5523 #if 1 /* With TERM EXCHANGE some FC cards refuse to boot */ 5546 5524 qlt_send_busy(vha, atio, 0); 5547 5525 #else 5548 - qlt_send_term_exchange(vha, NULL, atio, 1); 5526 + qlt_send_term_exchange(vha, NULL, atio, 1, 0); 5549 5527 #endif 5550 5528 } else { 5551 5529 if (tgt->tgt_stop) { ··· 5554 5532 "command to target, sending TERM " 5555 5533 "EXCHANGE for rsp\n"); 5556 5534 qlt_send_term_exchange(vha, NULL, 5557 - atio, 1); 5535 + atio, 1, 0); 5558 5536 } else { 5559 5537 ql_dbg(ql_dbg_tgt, vha, 0xe060, 5560 5538 "qla_target(%d): Unable to send " ··· 5982 5960 return; 5983 5961 5984 5962 out_term: 5985 - qlt_send_term_exchange(vha, NULL, &prm->tm_iocb2, 0); 5963 + qlt_send_term_exchange(vha, NULL, &prm->tm_iocb2, 1, 0); 5986 5964 if (sess) 5987 5965 ha->tgt.tgt_ops->put_sess(sess); 5988 5966 spin_unlock_irqrestore(&ha->tgt.sess_lock, flags);

+34 -25

drivers/scsi/qla2xxx/qla_target.h

··· 943 943 qlt_plogi_ack_t *plogi_link[QLT_PLOGI_LINK_MAX]; 944 944 }; 945 945 946 + typedef enum { 947 + /* 948 + * BIT_0 - Atio Arrival / schedule to work 949 + * BIT_1 - qlt_do_work 950 + * BIT_2 - qlt_do work failed 951 + * BIT_3 - xfer rdy/tcm_qla2xxx_write_pending 952 + * BIT_4 - read respond/tcm_qla2xx_queue_data_in 953 + * BIT_5 - status respond / tcm_qla2xx_queue_status 954 + * BIT_6 - tcm request to abort/Term exchange. 955 + * pre_xmit_response->qlt_send_term_exchange 956 + * BIT_7 - SRR received (qlt_handle_srr->qlt_xmit_response) 957 + * BIT_8 - SRR received (qlt_handle_srr->qlt_rdy_to_xfer) 958 + * BIT_9 - SRR received (qla_handle_srr->qlt_send_term_exchange) 959 + * BIT_10 - Data in - hanlde_data->tcm_qla2xxx_handle_data 960 + 961 + * BIT_12 - good completion - qlt_ctio_do_completion -->free_cmd 962 + * BIT_13 - Bad completion - 963 + * qlt_ctio_do_completion --> qlt_term_ctio_exchange 964 + * BIT_14 - Back end data received/sent. 965 + * BIT_15 - SRR prepare ctio 966 + * BIT_16 - complete free 967 + * BIT_17 - flush - qlt_abort_cmd_on_host_reset 968 + * BIT_18 - completion w/abort status 969 + * BIT_19 - completion w/unknown status 970 + * BIT_20 - tcm_qla2xxx_free_cmd 971 + */ 972 + CMD_FLAG_DATA_WORK = BIT_11, 973 + CMD_FLAG_DATA_WORK_FREE = BIT_21, 974 + } cmd_flags_t; 975 + 946 976 struct qla_tgt_cmd { 947 977 struct se_cmd se_cmd; 948 978 struct qla_tgt_sess *sess; ··· 982 952 /* Sense buffer that will be mapped into outgoing status */ 983 953 unsigned char sense_buffer[TRANSPORT_SENSE_BUFFER]; 984 954 955 + spinlock_t cmd_lock; 985 956 /* to save extra sess dereferences */ 986 957 unsigned int conf_compl_supported:1; 987 958 unsigned int sg_mapped:1; ··· 1017 986 1018 987 uint64_t jiffies_at_alloc; 1019 988 uint64_t jiffies_at_free; 1020 - /* BIT_0 - Atio Arrival / schedule to work 1021 - * BIT_1 - qlt_do_work 1022 - * BIT_2 - qlt_do work failed 1023 - * BIT_3 - xfer rdy/tcm_qla2xxx_write_pending 1024 - * BIT_4 - read respond/tcm_qla2xx_queue_data_in 1025 - * BIT_5 - status respond / tcm_qla2xx_queue_status 1026 - * BIT_6 - tcm request to abort/Term exchange. 1027 - * pre_xmit_response->qlt_send_term_exchange 1028 - * BIT_7 - SRR received (qlt_handle_srr->qlt_xmit_response) 1029 - * BIT_8 - SRR received (qlt_handle_srr->qlt_rdy_to_xfer) 1030 - * BIT_9 - SRR received (qla_handle_srr->qlt_send_term_exchange) 1031 - * BIT_10 - Data in - hanlde_data->tcm_qla2xxx_handle_data 1032 - * BIT_11 - Data actually going to TCM : tcm_qla2xx_handle_data_work 1033 - * BIT_12 - good completion - qlt_ctio_do_completion -->free_cmd 1034 - * BIT_13 - Bad completion - 1035 - * qlt_ctio_do_completion --> qlt_term_ctio_exchange 1036 - * BIT_14 - Back end data received/sent. 1037 - * BIT_15 - SRR prepare ctio 1038 - * BIT_16 - complete free 1039 - * BIT_17 - flush - qlt_abort_cmd_on_host_reset 1040 - * BIT_18 - completion w/abort status 1041 - * BIT_19 - completion w/unknown status 1042 - */ 1043 - uint32_t cmd_flags; 989 + 990 + cmd_flags_t cmd_flags; 1044 991 }; 1045 992 1046 993 struct qla_tgt_sess_work_param { ··· 1157 1148 extern void qlt_response_pkt_all_vps(struct scsi_qla_host *, response_t *); 1158 1149 extern int qlt_rdy_to_xfer(struct qla_tgt_cmd *); 1159 1150 extern int qlt_xmit_response(struct qla_tgt_cmd *, int, uint8_t); 1160 - extern void qlt_abort_cmd(struct qla_tgt_cmd *); 1151 + extern int qlt_abort_cmd(struct qla_tgt_cmd *); 1161 1152 extern void qlt_xmit_tm_rsp(struct qla_tgt_mgmt_cmd *); 1162 1153 extern void qlt_free_mcmd(struct qla_tgt_mgmt_cmd *); 1163 1154 extern void qlt_free_cmd(struct qla_tgt_cmd *cmd);

+16

drivers/scsi/qla2xxx/qla_tmpl.c

··· 395 395 if (ent->t263.queue_type == T263_QUEUE_TYPE_REQ) { 396 396 for (i = 0; i < vha->hw->max_req_queues; i++) { 397 397 struct req_que *req = vha->hw->req_q_map[i]; 398 + 399 + if (!test_bit(i, vha->hw->req_qid_map)) 400 + continue; 401 + 398 402 if (req || !buf) { 399 403 length = req ? 400 404 req->length : REQUEST_ENTRY_CNT_24XX; ··· 412 408 } else if (ent->t263.queue_type == T263_QUEUE_TYPE_RSP) { 413 409 for (i = 0; i < vha->hw->max_rsp_queues; i++) { 414 410 struct rsp_que *rsp = vha->hw->rsp_q_map[i]; 411 + 412 + if (!test_bit(i, vha->hw->rsp_qid_map)) 413 + continue; 414 + 415 415 if (rsp || !buf) { 416 416 length = rsp ? 417 417 rsp->length : RESPONSE_ENTRY_CNT_MQ; ··· 642 634 if (ent->t274.queue_type == T274_QUEUE_TYPE_REQ_SHAD) { 643 635 for (i = 0; i < vha->hw->max_req_queues; i++) { 644 636 struct req_que *req = vha->hw->req_q_map[i]; 637 + 638 + if (!test_bit(i, vha->hw->req_qid_map)) 639 + continue; 640 + 645 641 if (req || !buf) { 646 642 qla27xx_insert16(i, buf, len); 647 643 qla27xx_insert16(1, buf, len); ··· 657 645 } else if (ent->t274.queue_type == T274_QUEUE_TYPE_RSP_SHAD) { 658 646 for (i = 0; i < vha->hw->max_rsp_queues; i++) { 659 647 struct rsp_que *rsp = vha->hw->rsp_q_map[i]; 648 + 649 + if (!test_bit(i, vha->hw->rsp_qid_map)) 650 + continue; 651 + 660 652 if (rsp || !buf) { 661 653 qla27xx_insert16(i, buf, len); 662 654 qla27xx_insert16(1, buf, len);

+73 -3

drivers/scsi/qla2xxx/tcm_qla2xxx.c

··· 298 298 { 299 299 cmd->vha->tgt_counters.core_qla_free_cmd++; 300 300 cmd->cmd_in_wq = 1; 301 + 302 + BUG_ON(cmd->cmd_flags & BIT_20); 303 + cmd->cmd_flags |= BIT_20; 304 + 301 305 INIT_WORK(&cmd->work, tcm_qla2xxx_complete_free); 302 306 queue_work_on(smp_processor_id(), tcm_qla2xxx_free_wq, &cmd->work); 303 307 } ··· 378 374 { 379 375 struct qla_tgt_cmd *cmd = container_of(se_cmd, 380 376 struct qla_tgt_cmd, se_cmd); 377 + 378 + if (cmd->aborted) { 379 + /* Cmd can loop during Q-full. tcm_qla2xxx_aborted_task 380 + * can get ahead of this cmd. tcm_qla2xxx_aborted_task 381 + * already kick start the free. 382 + */ 383 + pr_debug("write_pending aborted cmd[%p] refcount %d " 384 + "transport_state %x, t_state %x, se_cmd_flags %x\n", 385 + cmd,cmd->se_cmd.cmd_kref.refcount.counter, 386 + cmd->se_cmd.transport_state, 387 + cmd->se_cmd.t_state, 388 + cmd->se_cmd.se_cmd_flags); 389 + return 0; 390 + } 381 391 cmd->cmd_flags |= BIT_3; 382 392 cmd->bufflen = se_cmd->data_length; 383 393 cmd->dma_data_direction = target_reverse_dma_direction(se_cmd); ··· 423 405 se_cmd->t_state == TRANSPORT_COMPLETE_QF_WP) { 424 406 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags); 425 407 wait_for_completion_timeout(&se_cmd->t_transport_stop_comp, 426 - 3 * HZ); 408 + 50); 427 409 return 0; 428 410 } 429 411 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags); ··· 462 444 if (bidi) 463 445 flags |= TARGET_SCF_BIDI_OP; 464 446 447 + if (se_cmd->cpuid != WORK_CPU_UNBOUND) 448 + flags |= TARGET_SCF_USE_CPUID; 449 + 465 450 sess = cmd->sess; 466 451 if (!sess) { 467 452 pr_err("Unable to locate struct qla_tgt_sess from qla_tgt_cmd\n"); ··· 486 465 static void tcm_qla2xxx_handle_data_work(struct work_struct *work) 487 466 { 488 467 struct qla_tgt_cmd *cmd = container_of(work, struct qla_tgt_cmd, work); 468 + unsigned long flags; 489 469 490 470 /* 491 471 * Ensure that the complete FCP WRITE payload has been received. 492 472 * Otherwise return an exception via CHECK_CONDITION status. 493 473 */ 494 474 cmd->cmd_in_wq = 0; 495 - cmd->cmd_flags |= BIT_11; 475 + 476 + spin_lock_irqsave(&cmd->cmd_lock, flags); 477 + cmd->cmd_flags |= CMD_FLAG_DATA_WORK; 478 + if (cmd->aborted) { 479 + cmd->cmd_flags |= CMD_FLAG_DATA_WORK_FREE; 480 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 481 + 482 + tcm_qla2xxx_free_cmd(cmd); 483 + return; 484 + } 485 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 486 + 496 487 cmd->vha->tgt_counters.qla_core_ret_ctio++; 497 488 if (!cmd->write_data_transferred) { 498 489 /* ··· 578 545 { 579 546 struct qla_tgt_cmd *cmd = container_of(se_cmd, 580 547 struct qla_tgt_cmd, se_cmd); 548 + 549 + if (cmd->aborted) { 550 + /* Cmd can loop during Q-full. tcm_qla2xxx_aborted_task 551 + * can get ahead of this cmd. tcm_qla2xxx_aborted_task 552 + * already kick start the free. 553 + */ 554 + pr_debug("queue_data_in aborted cmd[%p] refcount %d " 555 + "transport_state %x, t_state %x, se_cmd_flags %x\n", 556 + cmd,cmd->se_cmd.cmd_kref.refcount.counter, 557 + cmd->se_cmd.transport_state, 558 + cmd->se_cmd.t_state, 559 + cmd->se_cmd.se_cmd_flags); 560 + return 0; 561 + } 581 562 582 563 cmd->cmd_flags |= BIT_4; 583 564 cmd->bufflen = se_cmd->data_length; ··· 684 637 qlt_xmit_tm_rsp(mcmd); 685 638 } 686 639 640 + 641 + #define DATA_WORK_NOT_FREE(_flags) \ 642 + (( _flags & (CMD_FLAG_DATA_WORK|CMD_FLAG_DATA_WORK_FREE)) == \ 643 + CMD_FLAG_DATA_WORK) 687 644 static void tcm_qla2xxx_aborted_task(struct se_cmd *se_cmd) 688 645 { 689 646 struct qla_tgt_cmd *cmd = container_of(se_cmd, 690 647 struct qla_tgt_cmd, se_cmd); 691 - qlt_abort_cmd(cmd); 648 + unsigned long flags; 649 + 650 + if (qlt_abort_cmd(cmd)) 651 + return; 652 + 653 + spin_lock_irqsave(&cmd->cmd_lock, flags); 654 + if ((cmd->state == QLA_TGT_STATE_NEW)|| 655 + ((cmd->state == QLA_TGT_STATE_DATA_IN) && 656 + DATA_WORK_NOT_FREE(cmd->cmd_flags)) ) { 657 + 658 + cmd->cmd_flags |= CMD_FLAG_DATA_WORK_FREE; 659 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 660 + /* Cmd have not reached firmware. 661 + * Use this trigger to free it. */ 662 + tcm_qla2xxx_free_cmd(cmd); 663 + return; 664 + } 665 + spin_unlock_irqrestore(&cmd->cmd_lock, flags); 666 + return; 667 + 692 668 } 693 669 694 670 static void tcm_qla2xxx_clear_sess_lookup(struct tcm_qla2xxx_lport *,

+1 -1

drivers/target/target_core_configfs.c

··· 898 898 da->unmap_zeroes_data = flag; 899 899 pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n", 900 900 da->da_dev, flag); 901 - return 0; 901 + return count; 902 902 } 903 903 904 904 /*

+44

drivers/target/target_core_device.c

··· 828 828 return dev; 829 829 } 830 830 831 + /* 832 + * Check if the underlying struct block_device request_queue supports 833 + * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM 834 + * in ATA and we need to set TPE=1 835 + */ 836 + bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, 837 + struct request_queue *q, int block_size) 838 + { 839 + if (!blk_queue_discard(q)) 840 + return false; 841 + 842 + attrib->max_unmap_lba_count = (q->limits.max_discard_sectors << 9) / 843 + block_size; 844 + /* 845 + * Currently hardcoded to 1 in Linux/SCSI code.. 846 + */ 847 + attrib->max_unmap_block_desc_count = 1; 848 + attrib->unmap_granularity = q->limits.discard_granularity / block_size; 849 + attrib->unmap_granularity_alignment = q->limits.discard_alignment / 850 + block_size; 851 + attrib->unmap_zeroes_data = q->limits.discard_zeroes_data; 852 + return true; 853 + } 854 + EXPORT_SYMBOL(target_configure_unmap_from_queue); 855 + 856 + /* 857 + * Convert from blocksize advertised to the initiator to the 512 byte 858 + * units unconditionally used by the Linux block layer. 859 + */ 860 + sector_t target_to_linux_sector(struct se_device *dev, sector_t lb) 861 + { 862 + switch (dev->dev_attrib.block_size) { 863 + case 4096: 864 + return lb << 3; 865 + case 2048: 866 + return lb << 2; 867 + case 1024: 868 + return lb << 1; 869 + default: 870 + return lb; 871 + } 872 + } 873 + EXPORT_SYMBOL(target_to_linux_sector); 874 + 831 875 int target_configure_device(struct se_device *dev) 832 876 { 833 877 struct se_hba *hba = dev->se_hba;

+9 -20

drivers/target/target_core_file.c

··· 160 160 " block_device blocks: %llu logical_block_size: %d\n", 161 161 dev_size, div_u64(dev_size, fd_dev->fd_block_size), 162 162 fd_dev->fd_block_size); 163 - /* 164 - * Check if the underlying struct block_device request_queue supports 165 - * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM 166 - * in ATA and we need to set TPE=1 167 - */ 168 - if (blk_queue_discard(q)) { 169 - dev->dev_attrib.max_unmap_lba_count = 170 - q->limits.max_discard_sectors; 171 - /* 172 - * Currently hardcoded to 1 in Linux/SCSI code.. 173 - */ 174 - dev->dev_attrib.max_unmap_block_desc_count = 1; 175 - dev->dev_attrib.unmap_granularity = 176 - q->limits.discard_granularity >> 9; 177 - dev->dev_attrib.unmap_granularity_alignment = 178 - q->limits.discard_alignment; 163 + 164 + if (target_configure_unmap_from_queue(&dev->dev_attrib, q, 165 + fd_dev->fd_block_size)) 179 166 pr_debug("IFILE: BLOCK Discard support available," 180 - " disabled by default\n"); 181 - } 167 + " disabled by default\n"); 182 168 /* 183 169 * Enable write same emulation for IBLOCK and use 0xFFFF as 184 170 * the smaller WRITE_SAME(10) only has a two-byte block count. ··· 476 490 if (S_ISBLK(inode->i_mode)) { 477 491 /* The backend is block device, use discard */ 478 492 struct block_device *bdev = inode->i_bdev; 493 + struct se_device *dev = cmd->se_dev; 479 494 480 - ret = blkdev_issue_discard(bdev, lba, 481 - nolb, GFP_KERNEL, 0); 495 + ret = blkdev_issue_discard(bdev, 496 + target_to_linux_sector(dev, lba), 497 + target_to_linux_sector(dev, nolb), 498 + GFP_KERNEL, 0); 482 499 if (ret < 0) { 483 500 pr_warn("FILEIO: blkdev_issue_discard() failed: %d\n", 484 501 ret);

+14 -44

drivers/target/target_core_iblock.c

··· 121 121 dev->dev_attrib.hw_max_sectors = queue_max_hw_sectors(q); 122 122 dev->dev_attrib.hw_queue_depth = q->nr_requests; 123 123 124 - /* 125 - * Check if the underlying struct block_device request_queue supports 126 - * the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM 127 - * in ATA and we need to set TPE=1 128 - */ 129 - if (blk_queue_discard(q)) { 130 - dev->dev_attrib.max_unmap_lba_count = 131 - q->limits.max_discard_sectors; 132 - 133 - /* 134 - * Currently hardcoded to 1 in Linux/SCSI code.. 135 - */ 136 - dev->dev_attrib.max_unmap_block_desc_count = 1; 137 - dev->dev_attrib.unmap_granularity = 138 - q->limits.discard_granularity >> 9; 139 - dev->dev_attrib.unmap_granularity_alignment = 140 - q->limits.discard_alignment; 141 - dev->dev_attrib.unmap_zeroes_data = 142 - q->limits.discard_zeroes_data; 143 - 124 + if (target_configure_unmap_from_queue(&dev->dev_attrib, q, 125 + dev->dev_attrib.hw_block_size)) 144 126 pr_debug("IBLOCK: BLOCK Discard support available," 145 - " disabled by default\n"); 146 - } 127 + " disabled by default\n"); 128 + 147 129 /* 148 130 * Enable write same emulation for IBLOCK and use 0xFFFF as 149 131 * the smaller WRITE_SAME(10) only has a two-byte block count. ··· 397 415 iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb) 398 416 { 399 417 struct block_device *bdev = IBLOCK_DEV(cmd->se_dev)->ibd_bd; 418 + struct se_device *dev = cmd->se_dev; 400 419 int ret; 401 420 402 - ret = blkdev_issue_discard(bdev, lba, nolb, GFP_KERNEL, 0); 421 + ret = blkdev_issue_discard(bdev, 422 + target_to_linux_sector(dev, lba), 423 + target_to_linux_sector(dev, nolb), 424 + GFP_KERNEL, 0); 403 425 if (ret < 0) { 404 426 pr_err("blkdev_issue_discard() failed: %d\n", ret); 405 427 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; ··· 419 433 struct scatterlist *sg; 420 434 struct bio *bio; 421 435 struct bio_list list; 422 - sector_t block_lba = cmd->t_task_lba; 423 - sector_t sectors = sbc_get_write_same_sectors(cmd); 436 + struct se_device *dev = cmd->se_dev; 437 + sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 438 + sector_t sectors = target_to_linux_sector(dev, 439 + sbc_get_write_same_sectors(cmd)); 424 440 425 441 if (cmd->prot_op) { 426 442 pr_err("WRITE_SAME: Protection information with IBLOCK" ··· 636 648 enum dma_data_direction data_direction) 637 649 { 638 650 struct se_device *dev = cmd->se_dev; 651 + sector_t block_lba = target_to_linux_sector(dev, cmd->t_task_lba); 639 652 struct iblock_req *ibr; 640 653 struct bio *bio, *bio_start; 641 654 struct bio_list list; 642 655 struct scatterlist *sg; 643 656 u32 sg_num = sgl_nents; 644 - sector_t block_lba; 645 657 unsigned bio_cnt; 646 658 int rw = 0; 647 659 int i; ··· 665 677 } 666 678 } else { 667 679 rw = READ; 668 - } 669 - 670 - /* 671 - * Convert the blocksize advertised to the initiator to the 512 byte 672 - * units unconditionally used by the Linux block layer. 673 - */ 674 - if (dev->dev_attrib.block_size == 4096) 675 - block_lba = (cmd->t_task_lba << 3); 676 - else if (dev->dev_attrib.block_size == 2048) 677 - block_lba = (cmd->t_task_lba << 2); 678 - else if (dev->dev_attrib.block_size == 1024) 679 - block_lba = (cmd->t_task_lba << 1); 680 - else if (dev->dev_attrib.block_size == 512) 681 - block_lba = cmd->t_task_lba; 682 - else { 683 - pr_err("Unsupported SCSI -> BLOCK LBA conversion:" 684 - " %u\n", dev->dev_attrib.block_size); 685 - return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 686 680 } 687 681 688 682 ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);

-1

drivers/target/target_core_internal.h

··· 141 141 int transport_dump_vpd_assoc(struct t10_vpd *, unsigned char *, int); 142 142 int transport_dump_vpd_ident_type(struct t10_vpd *, unsigned char *, int); 143 143 int transport_dump_vpd_ident(struct t10_vpd *, unsigned char *, int); 144 - bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags); 145 144 void transport_clear_lun_ref(struct se_lun *); 146 145 void transport_send_task_abort(struct se_cmd *); 147 146 sense_reason_t target_cmd_size_check(struct se_cmd *cmd, unsigned int size);

+103 -36

drivers/target/target_core_tmr.c

··· 68 68 69 69 if (dev) { 70 70 spin_lock_irqsave(&dev->se_tmr_lock, flags); 71 - list_del(&tmr->tmr_list); 71 + list_del_init(&tmr->tmr_list); 72 72 spin_unlock_irqrestore(&dev->se_tmr_lock, flags); 73 73 } 74 74 75 75 kfree(tmr); 76 76 } 77 77 78 - static void core_tmr_handle_tas_abort( 79 - struct se_node_acl *tmr_nacl, 80 - struct se_cmd *cmd, 81 - int tas) 78 + static void core_tmr_handle_tas_abort(struct se_cmd *cmd, int tas) 82 79 { 83 - bool remove = true; 80 + unsigned long flags; 81 + bool remove = true, send_tas; 84 82 /* 85 83 * TASK ABORTED status (TAS) bit support 86 84 */ 87 - if ((tmr_nacl && (tmr_nacl != cmd->se_sess->se_node_acl)) && tas) { 85 + spin_lock_irqsave(&cmd->t_state_lock, flags); 86 + send_tas = (cmd->transport_state & CMD_T_TAS); 87 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 88 + 89 + if (send_tas) { 88 90 remove = false; 89 91 transport_send_task_abort(cmd); 90 92 } ··· 107 105 } 108 106 109 107 return 1; 108 + } 109 + 110 + static bool __target_check_io_state(struct se_cmd *se_cmd, 111 + struct se_session *tmr_sess, int tas) 112 + { 113 + struct se_session *sess = se_cmd->se_sess; 114 + 115 + assert_spin_locked(&sess->sess_cmd_lock); 116 + WARN_ON_ONCE(!irqs_disabled()); 117 + /* 118 + * If command already reached CMD_T_COMPLETE state within 119 + * target_complete_cmd() or CMD_T_FABRIC_STOP due to shutdown, 120 + * this se_cmd has been passed to fabric driver and will 121 + * not be aborted. 122 + * 123 + * Otherwise, obtain a local se_cmd->cmd_kref now for TMR 124 + * ABORT_TASK + LUN_RESET for CMD_T_ABORTED processing as 125 + * long as se_cmd->cmd_kref is still active unless zero. 126 + */ 127 + spin_lock(&se_cmd->t_state_lock); 128 + if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) { 129 + pr_debug("Attempted to abort io tag: %llu already complete or" 130 + " fabric stop, skipping\n", se_cmd->tag); 131 + spin_unlock(&se_cmd->t_state_lock); 132 + return false; 133 + } 134 + if (sess->sess_tearing_down || se_cmd->cmd_wait_set) { 135 + pr_debug("Attempted to abort io tag: %llu already shutdown," 136 + " skipping\n", se_cmd->tag); 137 + spin_unlock(&se_cmd->t_state_lock); 138 + return false; 139 + } 140 + se_cmd->transport_state |= CMD_T_ABORTED; 141 + 142 + if ((tmr_sess != se_cmd->se_sess) && tas) 143 + se_cmd->transport_state |= CMD_T_TAS; 144 + 145 + spin_unlock(&se_cmd->t_state_lock); 146 + 147 + return kref_get_unless_zero(&se_cmd->cmd_kref); 110 148 } 111 149 112 150 void core_tmr_abort_task( ··· 172 130 if (tmr->ref_task_tag != ref_tag) 173 131 continue; 174 132 175 - if (!kref_get_unless_zero(&se_cmd->cmd_kref)) 176 - continue; 177 - 178 133 printk("ABORT_TASK: Found referenced %s task_tag: %llu\n", 179 134 se_cmd->se_tfo->get_fabric_name(), ref_tag); 180 135 181 - spin_lock(&se_cmd->t_state_lock); 182 - if (se_cmd->transport_state & CMD_T_COMPLETE) { 183 - printk("ABORT_TASK: ref_tag: %llu already complete," 184 - " skipping\n", ref_tag); 185 - spin_unlock(&se_cmd->t_state_lock); 136 + if (!__target_check_io_state(se_cmd, se_sess, 0)) { 186 137 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 187 - 188 138 target_put_sess_cmd(se_cmd); 189 - 190 139 goto out; 191 140 } 192 - se_cmd->transport_state |= CMD_T_ABORTED; 193 - spin_unlock(&se_cmd->t_state_lock); 194 - 195 141 list_del_init(&se_cmd->se_cmd_list); 196 142 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 197 143 198 144 cancel_work_sync(&se_cmd->work); 199 145 transport_wait_for_tasks(se_cmd); 200 146 201 - target_put_sess_cmd(se_cmd); 202 147 transport_cmd_finish_abort(se_cmd, true); 148 + target_put_sess_cmd(se_cmd); 203 149 204 150 printk("ABORT_TASK: Sending TMR_FUNCTION_COMPLETE for" 205 151 " ref_tag: %llu\n", ref_tag); ··· 208 178 struct list_head *preempt_and_abort_list) 209 179 { 210 180 LIST_HEAD(drain_tmr_list); 181 + struct se_session *sess; 211 182 struct se_tmr_req *tmr_p, *tmr_pp; 212 183 struct se_cmd *cmd; 213 184 unsigned long flags; 185 + bool rc; 214 186 /* 215 187 * Release all pending and outgoing TMRs aside from the received 216 188 * LUN_RESET tmr.. ··· 238 206 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd)) 239 207 continue; 240 208 209 + sess = cmd->se_sess; 210 + if (WARN_ON_ONCE(!sess)) 211 + continue; 212 + 213 + spin_lock(&sess->sess_cmd_lock); 241 214 spin_lock(&cmd->t_state_lock); 242 - if (!(cmd->transport_state & CMD_T_ACTIVE)) { 215 + if (!(cmd->transport_state & CMD_T_ACTIVE) || 216 + (cmd->transport_state & CMD_T_FABRIC_STOP)) { 243 217 spin_unlock(&cmd->t_state_lock); 218 + spin_unlock(&sess->sess_cmd_lock); 244 219 continue; 245 220 } 246 221 if (cmd->t_state == TRANSPORT_ISTATE_PROCESSING) { 247 222 spin_unlock(&cmd->t_state_lock); 223 + spin_unlock(&sess->sess_cmd_lock); 248 224 continue; 249 225 } 226 + if (sess->sess_tearing_down || cmd->cmd_wait_set) { 227 + spin_unlock(&cmd->t_state_lock); 228 + spin_unlock(&sess->sess_cmd_lock); 229 + continue; 230 + } 231 + cmd->transport_state |= CMD_T_ABORTED; 250 232 spin_unlock(&cmd->t_state_lock); 233 + 234 + rc = kref_get_unless_zero(&cmd->cmd_kref); 235 + if (!rc) { 236 + printk("LUN_RESET TMR: non-zero kref_get_unless_zero\n"); 237 + spin_unlock(&sess->sess_cmd_lock); 238 + continue; 239 + } 240 + spin_unlock(&sess->sess_cmd_lock); 251 241 252 242 list_move_tail(&tmr_p->tmr_list, &drain_tmr_list); 253 243 } ··· 284 230 (preempt_and_abort_list) ? "Preempt" : "", tmr_p, 285 231 tmr_p->function, tmr_p->response, cmd->t_state); 286 232 233 + cancel_work_sync(&cmd->work); 234 + transport_wait_for_tasks(cmd); 235 + 287 236 transport_cmd_finish_abort(cmd, 1); 237 + target_put_sess_cmd(cmd); 288 238 } 289 239 } 290 240 291 241 static void core_tmr_drain_state_list( 292 242 struct se_device *dev, 293 243 struct se_cmd *prout_cmd, 294 - struct se_node_acl *tmr_nacl, 244 + struct se_session *tmr_sess, 295 245 int tas, 296 246 struct list_head *preempt_and_abort_list) 297 247 { 298 248 LIST_HEAD(drain_task_list); 249 + struct se_session *sess; 299 250 struct se_cmd *cmd, *next; 300 251 unsigned long flags; 252 + int rc; 301 253 302 254 /* 303 255 * Complete outstanding commands with TASK_ABORTED SAM status. ··· 342 282 if (prout_cmd == cmd) 343 283 continue; 344 284 285 + sess = cmd->se_sess; 286 + if (WARN_ON_ONCE(!sess)) 287 + continue; 288 + 289 + spin_lock(&sess->sess_cmd_lock); 290 + rc = __target_check_io_state(cmd, tmr_sess, tas); 291 + spin_unlock(&sess->sess_cmd_lock); 292 + if (!rc) 293 + continue; 294 + 345 295 list_move_tail(&cmd->state_list, &drain_task_list); 346 296 cmd->state_active = false; 347 297 } ··· 359 289 360 290 while (!list_empty(&drain_task_list)) { 361 291 cmd = list_entry(drain_task_list.next, struct se_cmd, state_list); 362 - list_del(&cmd->state_list); 292 + list_del_init(&cmd->state_list); 363 293 364 294 pr_debug("LUN_RESET: %s cmd: %p" 365 295 " ITT/CmdSN: 0x%08llx/0x%08x, i_state: %d, t_state: %d" ··· 383 313 * loop above, but we do it down here given that 384 314 * cancel_work_sync may block. 385 315 */ 386 - if (cmd->t_state == TRANSPORT_COMPLETE) 387 - cancel_work_sync(&cmd->work); 316 + cancel_work_sync(&cmd->work); 317 + transport_wait_for_tasks(cmd); 388 318 389 - spin_lock_irqsave(&cmd->t_state_lock, flags); 390 - target_stop_cmd(cmd, &flags); 391 - 392 - cmd->transport_state |= CMD_T_ABORTED; 393 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 394 - 395 - core_tmr_handle_tas_abort(tmr_nacl, cmd, tas); 319 + core_tmr_handle_tas_abort(cmd, tas); 320 + target_put_sess_cmd(cmd); 396 321 } 397 322 } 398 323 ··· 399 334 { 400 335 struct se_node_acl *tmr_nacl = NULL; 401 336 struct se_portal_group *tmr_tpg = NULL; 337 + struct se_session *tmr_sess = NULL; 402 338 int tas; 403 339 /* 404 340 * TASK_ABORTED status bit, this is configurable via ConfigFS ··· 418 352 * or struct se_device passthrough.. 419 353 */ 420 354 if (tmr && tmr->task_cmd && tmr->task_cmd->se_sess) { 421 - tmr_nacl = tmr->task_cmd->se_sess->se_node_acl; 422 - tmr_tpg = tmr->task_cmd->se_sess->se_tpg; 355 + tmr_sess = tmr->task_cmd->se_sess; 356 + tmr_nacl = tmr_sess->se_node_acl; 357 + tmr_tpg = tmr_sess->se_tpg; 423 358 if (tmr_nacl && tmr_tpg) { 424 359 pr_debug("LUN_RESET: TMR caller fabric: %s" 425 360 " initiator port %s\n", ··· 433 366 dev->transport->name, tas); 434 367 435 368 core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list); 436 - core_tmr_drain_state_list(dev, prout_cmd, tmr_nacl, tas, 369 + core_tmr_drain_state_list(dev, prout_cmd, tmr_sess, tas, 437 370 preempt_and_abort_list); 438 371 439 372 /*

+213 -132

drivers/target/target_core_transport.c

··· 534 534 } 535 535 EXPORT_SYMBOL(transport_deregister_session); 536 536 537 - /* 538 - * Called with cmd->t_state_lock held. 539 - */ 540 537 static void target_remove_from_state_list(struct se_cmd *cmd) 541 538 { 542 539 struct se_device *dev = cmd->se_dev; ··· 558 561 { 559 562 unsigned long flags; 560 563 561 - spin_lock_irqsave(&cmd->t_state_lock, flags); 562 - if (write_pending) 563 - cmd->t_state = TRANSPORT_WRITE_PENDING; 564 - 565 564 if (remove_from_lists) { 566 565 target_remove_from_state_list(cmd); 567 566 ··· 566 573 */ 567 574 cmd->se_lun = NULL; 568 575 } 576 + 577 + spin_lock_irqsave(&cmd->t_state_lock, flags); 578 + if (write_pending) 579 + cmd->t_state = TRANSPORT_WRITE_PENDING; 569 580 570 581 /* 571 582 * Determine if frontend context caller is requesting the stopping of ··· 624 627 625 628 void transport_cmd_finish_abort(struct se_cmd *cmd, int remove) 626 629 { 630 + bool ack_kref = (cmd->se_cmd_flags & SCF_ACK_KREF); 631 + 627 632 if (cmd->se_cmd_flags & SCF_SE_LUN_CMD) 628 633 transport_lun_remove_cmd(cmd); 629 634 /* ··· 637 638 638 639 if (transport_cmd_check_stop_to_fabric(cmd)) 639 640 return; 640 - if (remove) 641 + if (remove && ack_kref) 641 642 transport_put_cmd(cmd); 642 643 } 643 644 ··· 693 694 } 694 695 695 696 /* 696 - * See if we are waiting to complete for an exception condition. 697 - */ 698 - if (cmd->transport_state & CMD_T_REQUEST_STOP) { 699 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 700 - complete(&cmd->task_stop_comp); 701 - return; 702 - } 703 - 704 - /* 705 697 * Check for case where an explicit ABORT_TASK has been received 706 698 * and transport_wait_for_tasks() will be waiting for completion.. 707 699 */ 708 - if (cmd->transport_state & CMD_T_ABORTED && 700 + if (cmd->transport_state & CMD_T_ABORTED || 709 701 cmd->transport_state & CMD_T_STOP) { 710 702 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 711 703 complete_all(&cmd->t_transport_stop_comp); ··· 711 721 cmd->transport_state |= (CMD_T_COMPLETE | CMD_T_ACTIVE); 712 722 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 713 723 714 - if (cmd->cpuid == -1) 715 - queue_work(target_completion_wq, &cmd->work); 716 - else 724 + if (cmd->se_cmd_flags & SCF_USE_CPUID) 717 725 queue_work_on(cmd->cpuid, target_completion_wq, &cmd->work); 726 + else 727 + queue_work(target_completion_wq, &cmd->work); 718 728 } 719 729 EXPORT_SYMBOL(target_complete_cmd); 720 730 ··· 1193 1203 INIT_LIST_HEAD(&cmd->state_list); 1194 1204 init_completion(&cmd->t_transport_stop_comp); 1195 1205 init_completion(&cmd->cmd_wait_comp); 1196 - init_completion(&cmd->task_stop_comp); 1197 1206 spin_lock_init(&cmd->t_state_lock); 1198 1207 kref_init(&cmd->cmd_kref); 1199 1208 cmd->transport_state = CMD_T_DEV_ACTIVE; ··· 1426 1437 */ 1427 1438 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 1428 1439 data_length, data_dir, task_attr, sense); 1440 + 1441 + if (flags & TARGET_SCF_USE_CPUID) 1442 + se_cmd->se_cmd_flags |= SCF_USE_CPUID; 1443 + else 1444 + se_cmd->cpuid = WORK_CPU_UNBOUND; 1445 + 1429 1446 if (flags & TARGET_SCF_UNKNOWN_SIZE) 1430 1447 se_cmd->unknown_data_length = 1; 1431 1448 /* ··· 1628 1633 return 0; 1629 1634 } 1630 1635 EXPORT_SYMBOL(target_submit_tmr); 1631 - 1632 - /* 1633 - * If the cmd is active, request it to be stopped and sleep until it 1634 - * has completed. 1635 - */ 1636 - bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags) 1637 - __releases(&cmd->t_state_lock) 1638 - __acquires(&cmd->t_state_lock) 1639 - { 1640 - bool was_active = false; 1641 - 1642 - if (cmd->transport_state & CMD_T_BUSY) { 1643 - cmd->transport_state |= CMD_T_REQUEST_STOP; 1644 - spin_unlock_irqrestore(&cmd->t_state_lock, *flags); 1645 - 1646 - pr_debug("cmd %p waiting to complete\n", cmd); 1647 - wait_for_completion(&cmd->task_stop_comp); 1648 - pr_debug("cmd %p stopped successfully\n", cmd); 1649 - 1650 - spin_lock_irqsave(&cmd->t_state_lock, *flags); 1651 - cmd->transport_state &= ~CMD_T_REQUEST_STOP; 1652 - cmd->transport_state &= ~CMD_T_BUSY; 1653 - was_active = true; 1654 - } 1655 - 1656 - return was_active; 1657 - } 1658 1636 1659 1637 /* 1660 1638 * Handle SAM-esque emulation for generic transport request failures. ··· 1827 1859 return true; 1828 1860 } 1829 1861 1862 + static int __transport_check_aborted_status(struct se_cmd *, int); 1863 + 1830 1864 void target_execute_cmd(struct se_cmd *cmd) 1831 1865 { 1832 1866 /* 1833 - * If the received CDB has aleady been aborted stop processing it here. 1834 - */ 1835 - if (transport_check_aborted_status(cmd, 1)) 1836 - return; 1837 - 1838 - /* 1839 1867 * Determine if frontend context caller is requesting the stopping of 1840 1868 * this command for frontend exceptions. 1869 + * 1870 + * If the received CDB has aleady been aborted stop processing it here. 1841 1871 */ 1842 1872 spin_lock_irq(&cmd->t_state_lock); 1873 + if (__transport_check_aborted_status(cmd, 1)) { 1874 + spin_unlock_irq(&cmd->t_state_lock); 1875 + return; 1876 + } 1843 1877 if (cmd->transport_state & CMD_T_STOP) { 1844 1878 pr_debug("%s:%d CMD_T_STOP for ITT: 0x%08llx\n", 1845 1879 __func__, __LINE__, cmd->tag); ··· 2192 2222 } 2193 2223 2194 2224 /** 2195 - * transport_release_cmd - free a command 2196 - * @cmd: command to free 2197 - * 2198 - * This routine unconditionally frees a command, and reference counting 2199 - * or list removal must be done in the caller. 2200 - */ 2201 - static int transport_release_cmd(struct se_cmd *cmd) 2202 - { 2203 - BUG_ON(!cmd->se_tfo); 2204 - 2205 - if (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) 2206 - core_tmr_release_req(cmd->se_tmr_req); 2207 - if (cmd->t_task_cdb != cmd->__t_task_cdb) 2208 - kfree(cmd->t_task_cdb); 2209 - /* 2210 - * If this cmd has been setup with target_get_sess_cmd(), drop 2211 - * the kref and call ->release_cmd() in kref callback. 2212 - */ 2213 - return target_put_sess_cmd(cmd); 2214 - } 2215 - 2216 - /** 2217 2225 * transport_put_cmd - release a reference to a command 2218 2226 * @cmd: command to release 2219 2227 * ··· 2199 2251 */ 2200 2252 static int transport_put_cmd(struct se_cmd *cmd) 2201 2253 { 2202 - transport_free_pages(cmd); 2203 - return transport_release_cmd(cmd); 2254 + BUG_ON(!cmd->se_tfo); 2255 + /* 2256 + * If this cmd has been setup with target_get_sess_cmd(), drop 2257 + * the kref and call ->release_cmd() in kref callback. 2258 + */ 2259 + return target_put_sess_cmd(cmd); 2204 2260 } 2205 2261 2206 2262 void *transport_kmap_data_sg(struct se_cmd *cmd) ··· 2402 2450 } 2403 2451 } 2404 2452 2405 - int transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks) 2453 + static bool 2454 + __transport_wait_for_tasks(struct se_cmd *, bool, bool *, bool *, 2455 + unsigned long *flags); 2456 + 2457 + static void target_wait_free_cmd(struct se_cmd *cmd, bool *aborted, bool *tas) 2406 2458 { 2407 2459 unsigned long flags; 2460 + 2461 + spin_lock_irqsave(&cmd->t_state_lock, flags); 2462 + __transport_wait_for_tasks(cmd, true, aborted, tas, &flags); 2463 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2464 + } 2465 + 2466 + int transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks) 2467 + { 2408 2468 int ret = 0; 2469 + bool aborted = false, tas = false; 2409 2470 2410 2471 if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD)) { 2411 2472 if (wait_for_tasks && (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) 2412 - transport_wait_for_tasks(cmd); 2473 + target_wait_free_cmd(cmd, &aborted, &tas); 2413 2474 2414 - ret = transport_release_cmd(cmd); 2475 + if (!aborted || tas) 2476 + ret = transport_put_cmd(cmd); 2415 2477 } else { 2416 2478 if (wait_for_tasks) 2417 - transport_wait_for_tasks(cmd); 2479 + target_wait_free_cmd(cmd, &aborted, &tas); 2418 2480 /* 2419 2481 * Handle WRITE failure case where transport_generic_new_cmd() 2420 2482 * has already added se_cmd to state_list, but fabric has 2421 2483 * failed command before I/O submission. 2422 2484 */ 2423 - if (cmd->state_active) { 2424 - spin_lock_irqsave(&cmd->t_state_lock, flags); 2485 + if (cmd->state_active) 2425 2486 target_remove_from_state_list(cmd); 2426 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2427 - } 2428 2487 2429 2488 if (cmd->se_lun) 2430 2489 transport_lun_remove_cmd(cmd); 2431 2490 2432 - ret = transport_put_cmd(cmd); 2491 + if (!aborted || tas) 2492 + ret = transport_put_cmd(cmd); 2493 + } 2494 + /* 2495 + * If the task has been internally aborted due to TMR ABORT_TASK 2496 + * or LUN_RESET, target_core_tmr.c is responsible for performing 2497 + * the remaining calls to target_put_sess_cmd(), and not the 2498 + * callers of this function. 2499 + */ 2500 + if (aborted) { 2501 + pr_debug("Detected CMD_T_ABORTED for ITT: %llu\n", cmd->tag); 2502 + wait_for_completion(&cmd->cmd_wait_comp); 2503 + cmd->se_tfo->release_cmd(cmd); 2504 + ret = 1; 2433 2505 } 2434 2506 return ret; 2435 2507 } ··· 2493 2517 } 2494 2518 EXPORT_SYMBOL(target_get_sess_cmd); 2495 2519 2520 + static void target_free_cmd_mem(struct se_cmd *cmd) 2521 + { 2522 + transport_free_pages(cmd); 2523 + 2524 + if (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB) 2525 + core_tmr_release_req(cmd->se_tmr_req); 2526 + if (cmd->t_task_cdb != cmd->__t_task_cdb) 2527 + kfree(cmd->t_task_cdb); 2528 + } 2529 + 2496 2530 static void target_release_cmd_kref(struct kref *kref) 2497 2531 { 2498 2532 struct se_cmd *se_cmd = container_of(kref, struct se_cmd, cmd_kref); 2499 2533 struct se_session *se_sess = se_cmd->se_sess; 2500 2534 unsigned long flags; 2535 + bool fabric_stop; 2501 2536 2502 2537 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags); 2503 2538 if (list_empty(&se_cmd->se_cmd_list)) { 2504 2539 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2540 + target_free_cmd_mem(se_cmd); 2505 2541 se_cmd->se_tfo->release_cmd(se_cmd); 2506 2542 return; 2507 2543 } 2508 - if (se_sess->sess_tearing_down && se_cmd->cmd_wait_set) { 2544 + 2545 + spin_lock(&se_cmd->t_state_lock); 2546 + fabric_stop = (se_cmd->transport_state & CMD_T_FABRIC_STOP); 2547 + spin_unlock(&se_cmd->t_state_lock); 2548 + 2549 + if (se_cmd->cmd_wait_set || fabric_stop) { 2550 + list_del_init(&se_cmd->se_cmd_list); 2509 2551 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2552 + target_free_cmd_mem(se_cmd); 2510 2553 complete(&se_cmd->cmd_wait_comp); 2511 2554 return; 2512 2555 } 2513 - list_del(&se_cmd->se_cmd_list); 2556 + list_del_init(&se_cmd->se_cmd_list); 2514 2557 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2515 2558 2559 + target_free_cmd_mem(se_cmd); 2516 2560 se_cmd->se_tfo->release_cmd(se_cmd); 2517 2561 } 2518 2562 ··· 2544 2548 struct se_session *se_sess = se_cmd->se_sess; 2545 2549 2546 2550 if (!se_sess) { 2551 + target_free_cmd_mem(se_cmd); 2547 2552 se_cmd->se_tfo->release_cmd(se_cmd); 2548 2553 return 1; 2549 2554 } ··· 2561 2564 { 2562 2565 struct se_cmd *se_cmd; 2563 2566 unsigned long flags; 2567 + int rc; 2564 2568 2565 2569 spin_lock_irqsave(&se_sess->sess_cmd_lock, flags); 2566 2570 if (se_sess->sess_tearing_down) { ··· 2571 2573 se_sess->sess_tearing_down = 1; 2572 2574 list_splice_init(&se_sess->sess_cmd_list, &se_sess->sess_wait_list); 2573 2575 2574 - list_for_each_entry(se_cmd, &se_sess->sess_wait_list, se_cmd_list) 2575 - se_cmd->cmd_wait_set = 1; 2576 + list_for_each_entry(se_cmd, &se_sess->sess_wait_list, se_cmd_list) { 2577 + rc = kref_get_unless_zero(&se_cmd->cmd_kref); 2578 + if (rc) { 2579 + se_cmd->cmd_wait_set = 1; 2580 + spin_lock(&se_cmd->t_state_lock); 2581 + se_cmd->transport_state |= CMD_T_FABRIC_STOP; 2582 + spin_unlock(&se_cmd->t_state_lock); 2583 + } 2584 + } 2576 2585 2577 2586 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2578 2587 } ··· 2592 2587 { 2593 2588 struct se_cmd *se_cmd, *tmp_cmd; 2594 2589 unsigned long flags; 2590 + bool tas; 2595 2591 2596 2592 list_for_each_entry_safe(se_cmd, tmp_cmd, 2597 2593 &se_sess->sess_wait_list, se_cmd_list) { 2598 - list_del(&se_cmd->se_cmd_list); 2594 + list_del_init(&se_cmd->se_cmd_list); 2599 2595 2600 2596 pr_debug("Waiting for se_cmd: %p t_state: %d, fabric state:" 2601 2597 " %d\n", se_cmd, se_cmd->t_state, 2602 2598 se_cmd->se_tfo->get_cmd_state(se_cmd)); 2599 + 2600 + spin_lock_irqsave(&se_cmd->t_state_lock, flags); 2601 + tas = (se_cmd->transport_state & CMD_T_TAS); 2602 + spin_unlock_irqrestore(&se_cmd->t_state_lock, flags); 2603 + 2604 + if (!target_put_sess_cmd(se_cmd)) { 2605 + if (tas) 2606 + target_put_sess_cmd(se_cmd); 2607 + } 2603 2608 2604 2609 wait_for_completion(&se_cmd->cmd_wait_comp); 2605 2610 pr_debug("After cmd_wait_comp: se_cmd: %p t_state: %d" ··· 2632 2617 wait_for_completion(&lun->lun_ref_comp); 2633 2618 } 2634 2619 2620 + static bool 2621 + __transport_wait_for_tasks(struct se_cmd *cmd, bool fabric_stop, 2622 + bool *aborted, bool *tas, unsigned long *flags) 2623 + __releases(&cmd->t_state_lock) 2624 + __acquires(&cmd->t_state_lock) 2625 + { 2626 + 2627 + assert_spin_locked(&cmd->t_state_lock); 2628 + WARN_ON_ONCE(!irqs_disabled()); 2629 + 2630 + if (fabric_stop) 2631 + cmd->transport_state |= CMD_T_FABRIC_STOP; 2632 + 2633 + if (cmd->transport_state & CMD_T_ABORTED) 2634 + *aborted = true; 2635 + 2636 + if (cmd->transport_state & CMD_T_TAS) 2637 + *tas = true; 2638 + 2639 + if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) && 2640 + !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) 2641 + return false; 2642 + 2643 + if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) && 2644 + !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) 2645 + return false; 2646 + 2647 + if (!(cmd->transport_state & CMD_T_ACTIVE)) 2648 + return false; 2649 + 2650 + if (fabric_stop && *aborted) 2651 + return false; 2652 + 2653 + cmd->transport_state |= CMD_T_STOP; 2654 + 2655 + pr_debug("wait_for_tasks: Stopping %p ITT: 0x%08llx i_state: %d," 2656 + " t_state: %d, CMD_T_STOP\n", cmd, cmd->tag, 2657 + cmd->se_tfo->get_cmd_state(cmd), cmd->t_state); 2658 + 2659 + spin_unlock_irqrestore(&cmd->t_state_lock, *flags); 2660 + 2661 + wait_for_completion(&cmd->t_transport_stop_comp); 2662 + 2663 + spin_lock_irqsave(&cmd->t_state_lock, *flags); 2664 + cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP); 2665 + 2666 + pr_debug("wait_for_tasks: Stopped wait_for_completion(&cmd->" 2667 + "t_transport_stop_comp) for ITT: 0x%08llx\n", cmd->tag); 2668 + 2669 + return true; 2670 + } 2671 + 2635 2672 /** 2636 2673 * transport_wait_for_tasks - wait for completion to occur 2637 2674 * @cmd: command to wait ··· 2694 2627 bool transport_wait_for_tasks(struct se_cmd *cmd) 2695 2628 { 2696 2629 unsigned long flags; 2630 + bool ret, aborted = false, tas = false; 2697 2631 2698 2632 spin_lock_irqsave(&cmd->t_state_lock, flags); 2699 - if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) && 2700 - !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) { 2701 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2702 - return false; 2703 - } 2704 - 2705 - if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) && 2706 - !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) { 2707 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2708 - return false; 2709 - } 2710 - 2711 - if (!(cmd->transport_state & CMD_T_ACTIVE)) { 2712 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2713 - return false; 2714 - } 2715 - 2716 - cmd->transport_state |= CMD_T_STOP; 2717 - 2718 - pr_debug("wait_for_tasks: Stopping %p ITT: 0x%08llx i_state: %d, t_state: %d, CMD_T_STOP\n", 2719 - cmd, cmd->tag, cmd->se_tfo->get_cmd_state(cmd), cmd->t_state); 2720 - 2633 + ret = __transport_wait_for_tasks(cmd, false, &aborted, &tas, &flags); 2721 2634 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2722 2635 2723 - wait_for_completion(&cmd->t_transport_stop_comp); 2724 - 2725 - spin_lock_irqsave(&cmd->t_state_lock, flags); 2726 - cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP); 2727 - 2728 - pr_debug("wait_for_tasks: Stopped wait_for_completion(&cmd->t_transport_stop_comp) for ITT: 0x%08llx\n", 2729 - cmd->tag); 2730 - 2731 - spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2732 - 2733 - return true; 2636 + return ret; 2734 2637 } 2735 2638 EXPORT_SYMBOL(transport_wait_for_tasks); 2736 2639 ··· 2882 2845 } 2883 2846 EXPORT_SYMBOL(transport_send_check_condition_and_sense); 2884 2847 2885 - int transport_check_aborted_status(struct se_cmd *cmd, int send_status) 2848 + static int __transport_check_aborted_status(struct se_cmd *cmd, int send_status) 2849 + __releases(&cmd->t_state_lock) 2850 + __acquires(&cmd->t_state_lock) 2886 2851 { 2852 + assert_spin_locked(&cmd->t_state_lock); 2853 + WARN_ON_ONCE(!irqs_disabled()); 2854 + 2887 2855 if (!(cmd->transport_state & CMD_T_ABORTED)) 2888 2856 return 0; 2889 - 2890 2857 /* 2891 2858 * If cmd has been aborted but either no status is to be sent or it has 2892 2859 * already been sent, just return 2893 2860 */ 2894 - if (!send_status || !(cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS)) 2861 + if (!send_status || !(cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS)) { 2862 + if (send_status) 2863 + cmd->se_cmd_flags |= SCF_SEND_DELAYED_TAS; 2895 2864 return 1; 2865 + } 2896 2866 2897 - pr_debug("Sending delayed SAM_STAT_TASK_ABORTED status for CDB: 0x%02x ITT: 0x%08llx\n", 2898 - cmd->t_task_cdb[0], cmd->tag); 2867 + pr_debug("Sending delayed SAM_STAT_TASK_ABORTED status for CDB:" 2868 + " 0x%02x ITT: 0x%08llx\n", cmd->t_task_cdb[0], cmd->tag); 2899 2869 2900 2870 cmd->se_cmd_flags &= ~SCF_SEND_DELAYED_TAS; 2901 2871 cmd->scsi_status = SAM_STAT_TASK_ABORTED; 2902 2872 trace_target_cmd_complete(cmd); 2873 + 2874 + spin_unlock_irq(&cmd->t_state_lock); 2903 2875 cmd->se_tfo->queue_status(cmd); 2876 + spin_lock_irq(&cmd->t_state_lock); 2904 2877 2905 2878 return 1; 2879 + } 2880 + 2881 + int transport_check_aborted_status(struct se_cmd *cmd, int send_status) 2882 + { 2883 + int ret; 2884 + 2885 + spin_lock_irq(&cmd->t_state_lock); 2886 + ret = __transport_check_aborted_status(cmd, send_status); 2887 + spin_unlock_irq(&cmd->t_state_lock); 2888 + 2889 + return ret; 2906 2890 } 2907 2891 EXPORT_SYMBOL(transport_check_aborted_status); 2908 2892 ··· 2946 2888 */ 2947 2889 if (cmd->data_direction == DMA_TO_DEVICE) { 2948 2890 if (cmd->se_tfo->write_pending_status(cmd) != 0) { 2949 - cmd->transport_state |= CMD_T_ABORTED; 2891 + spin_lock_irqsave(&cmd->t_state_lock, flags); 2892 + if (cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS) { 2893 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2894 + goto send_abort; 2895 + } 2950 2896 cmd->se_cmd_flags |= SCF_SEND_DELAYED_TAS; 2897 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2951 2898 return; 2952 2899 } 2953 2900 } 2901 + send_abort: 2954 2902 cmd->scsi_status = SAM_STAT_TASK_ABORTED; 2955 2903 2956 2904 transport_lun_remove_cmd(cmd); ··· 2973 2909 struct se_cmd *cmd = container_of(work, struct se_cmd, work); 2974 2910 struct se_device *dev = cmd->se_dev; 2975 2911 struct se_tmr_req *tmr = cmd->se_tmr_req; 2912 + unsigned long flags; 2976 2913 int ret; 2914 + 2915 + spin_lock_irqsave(&cmd->t_state_lock, flags); 2916 + if (cmd->transport_state & CMD_T_ABORTED) { 2917 + tmr->response = TMR_FUNCTION_REJECTED; 2918 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2919 + goto check_stop; 2920 + } 2921 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2977 2922 2978 2923 switch (tmr->function) { 2979 2924 case TMR_ABORT_TASK: ··· 3016 2943 break; 3017 2944 } 3018 2945 2946 + spin_lock_irqsave(&cmd->t_state_lock, flags); 2947 + if (cmd->transport_state & CMD_T_ABORTED) { 2948 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2949 + goto check_stop; 2950 + } 3019 2951 cmd->t_state = TRANSPORT_ISTATE_PROCESSING; 2952 + spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2953 + 3020 2954 cmd->se_tfo->queue_tm_rsp(cmd); 3021 2955 2956 + check_stop: 3022 2957 transport_cmd_check_stop_to_fabric(cmd); 3023 2958 } 3024 2959

+1 -1

drivers/target/target_core_user.c

··· 903 903 info->version = __stringify(TCMU_MAILBOX_VERSION); 904 904 905 905 info->mem[0].name = "tcm-user command & data buffer"; 906 - info->mem[0].addr = (phys_addr_t) udev->mb_addr; 906 + info->mem[0].addr = (phys_addr_t)(uintptr_t)udev->mb_addr; 907 907 info->mem[0].size = TCMU_RING_SIZE; 908 908 info->mem[0].memtype = UIO_MEM_VIRTUAL; 909 909

+3

include/target/target_core_backend.h

··· 94 94 sense_reason_t (*exec_cmd)(struct se_cmd *cmd)); 95 95 96 96 bool target_sense_desc_format(struct se_device *dev); 97 + sector_t target_to_linux_sector(struct se_device *dev, sector_t lb); 98 + bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, 99 + struct request_queue *q, int block_size); 97 100 98 101 #endif /* TARGET_CORE_BACKEND_H */

+5 -4

include/target/target_core_base.h

··· 140 140 SCF_COMPARE_AND_WRITE = 0x00080000, 141 141 SCF_COMPARE_AND_WRITE_POST = 0x00100000, 142 142 SCF_PASSTHROUGH_PROT_SG_TO_MEM_NOALLOC = 0x00200000, 143 + SCF_ACK_KREF = 0x00400000, 144 + SCF_USE_CPUID = 0x00800000, 143 145 }; 144 146 145 147 /* struct se_dev_entry->lun_flags and struct se_lun->lun_access */ ··· 189 187 TARGET_SCF_BIDI_OP = 0x01, 190 188 TARGET_SCF_ACK_KREF = 0x02, 191 189 TARGET_SCF_UNKNOWN_SIZE = 0x04, 190 + TARGET_SCF_USE_CPUID = 0x08, 192 191 }; 193 192 194 193 /* fabric independent task management function values */ ··· 493 490 #define CMD_T_SENT (1 << 4) 494 491 #define CMD_T_STOP (1 << 5) 495 492 #define CMD_T_DEV_ACTIVE (1 << 7) 496 - #define CMD_T_REQUEST_STOP (1 << 8) 497 493 #define CMD_T_BUSY (1 << 9) 494 + #define CMD_T_TAS (1 << 10) 495 + #define CMD_T_FABRIC_STOP (1 << 11) 498 496 spinlock_t t_state_lock; 499 497 struct kref cmd_kref; 500 498 struct completion t_transport_stop_comp; ··· 514 510 int lun_ref_active; 515 511 516 512 struct list_head state_list; 517 - 518 - /* old task stop completion, consider merging with some of the above */ 519 - struct completion task_stop_comp; 520 513 521 514 /* backend private data */ 522 515 void *priv;

Configure Feed

Configure Feed