Lines Matching refs:cmd
68 static void transport_complete_task_attr(struct se_cmd *cmd);
69 static void transport_handle_queue_full(struct se_cmd *cmd,
71 static int transport_put_cmd(struct se_cmd *cmd);
519 * Called with cmd->t_state_lock held.
521 static void target_remove_from_state_list(struct se_cmd *cmd)
523 struct se_device *dev = cmd->se_dev;
529 if (cmd->transport_state & CMD_T_BUSY)
533 if (cmd->state_active) {
534 list_del(&cmd->state_list);
535 cmd->state_active = false;
540 static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists,
545 spin_lock_irqsave(&cmd->t_state_lock, flags);
547 cmd->t_state = TRANSPORT_WRITE_PENDING;
550 target_remove_from_state_list(cmd);
555 cmd->se_lun = NULL;
562 if (cmd->transport_state & CMD_T_STOP) {
565 cmd->se_tfo->get_task_tag(cmd));
567 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
569 complete_all(&cmd->t_transport_stop_comp);
573 cmd->transport_state &= ~CMD_T_ACTIVE;
584 if (cmd->se_tfo->check_stop_free != NULL) {
585 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
586 return cmd->se_tfo->check_stop_free(cmd);
590 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
594 static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd)
596 return transport_cmd_check_stop(cmd, true, false);
599 static void transport_lun_remove_cmd(struct se_cmd *cmd)
601 struct se_lun *lun = cmd->se_lun;
606 if (cmpxchg(&cmd->lun_ref_active, true, false))
610 void transport_cmd_finish_abort(struct se_cmd *cmd, int remove)
612 if (cmd->se_cmd_flags & SCF_SE_LUN_CMD)
613 transport_lun_remove_cmd(cmd);
619 cmd->se_tfo->aborted_task(cmd);
621 if (transport_cmd_check_stop_to_fabric(cmd))
624 transport_put_cmd(cmd);
629 struct se_cmd *cmd = container_of(work, struct se_cmd, work);
631 transport_generic_request_failure(cmd,
639 static unsigned char *transport_get_sense_buffer(struct se_cmd *cmd)
641 struct se_device *dev = cmd->se_dev;
643 WARN_ON(!cmd->se_lun);
648 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION)
651 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER;
654 dev->se_hba->hba_id, dev->transport->name, cmd->scsi_status);
655 return cmd->sense_buffer;
658 void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status)
660 struct se_device *dev = cmd->se_dev;
664 cmd->scsi_status = scsi_status;
667 spin_lock_irqsave(&cmd->t_state_lock, flags);
668 cmd->transport_state &= ~CMD_T_BUSY;
671 dev->transport->transport_complete(cmd,
672 cmd->t_data_sg,
673 transport_get_sense_buffer(cmd));
674 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE)
681 if (cmd->transport_state & CMD_T_REQUEST_STOP) {
682 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
683 complete(&cmd->task_stop_comp);
691 if (cmd->transport_state & CMD_T_ABORTED &&
692 cmd->transport_state & CMD_T_STOP) {
693 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
694 complete_all(&cmd->t_transport_stop_comp);
697 INIT_WORK(&cmd->work, target_complete_failure_work);
699 INIT_WORK(&cmd->work, target_complete_ok_work);
702 cmd->t_state = TRANSPORT_COMPLETE;
703 cmd->transport_state |= (CMD_T_COMPLETE | CMD_T_ACTIVE);
704 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
706 queue_work(target_completion_wq, &cmd->work);
710 void target_complete_cmd_with_length(struct se_cmd *cmd, u8 scsi_status, int length)
712 if (scsi_status == SAM_STAT_GOOD && length < cmd->data_length) {
713 if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) {
714 cmd->residual_count += cmd->data_length - length;
716 cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
717 cmd->residual_count = cmd->data_length - length;
720 cmd->data_length = length;
723 target_complete_cmd(cmd, scsi_status);
727 static void target_add_to_state_list(struct se_cmd *cmd)
729 struct se_device *dev = cmd->se_dev;
733 if (!cmd->state_active) {
734 list_add_tail(&cmd->state_list, &dev->state_list);
735 cmd->state_active = true;
743 static void transport_write_pending_qf(struct se_cmd *cmd);
744 static void transport_complete_qf(struct se_cmd *cmd);
751 struct se_cmd *cmd, *cmd_tmp;
757 list_for_each_entry_safe(cmd, cmd_tmp, &qf_cmd_list, se_qf_node) {
758 list_del(&cmd->se_qf_node);
761 pr_debug("Processing %s cmd: %p QUEUE_FULL in work queue"
762 " context: %s\n", cmd->se_tfo->get_fabric_name(), cmd,
763 (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) ? "COMPLETE_OK" :
764 (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING"
767 if (cmd->t_state == TRANSPORT_COMPLETE_QF_WP)
768 transport_write_pending_qf(cmd);
769 else if (cmd->t_state == TRANSPORT_COMPLETE_QF_OK)
770 transport_complete_qf(cmd);
774 unsigned char *transport_dump_cmd_direction(struct se_cmd *cmd)
776 switch (cmd->data_direction) {
1067 target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
1069 struct se_device *dev = cmd->se_dev;
1071 if (cmd->unknown_data_length) {
1072 cmd->data_length = size;
1073 } else if (size != cmd->data_length) {
1076 " 0x%02x\n", cmd->se_tfo->get_fabric_name(),
1077 cmd->data_length, size, cmd->t_task_cdb[0]);
1079 if (cmd->data_direction == DMA_TO_DEVICE) {
1101 if (size > cmd->data_length) {
1102 cmd->se_cmd_flags |= SCF_OVERFLOW_BIT;
1103 cmd->residual_count = (size - cmd->data_length);
1105 cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT;
1106 cmd->residual_count = (cmd->data_length - size);
1107 cmd->data_length = size;
1120 struct se_cmd *cmd,
1128 INIT_LIST_HEAD(&cmd->se_delayed_node);
1129 INIT_LIST_HEAD(&cmd->se_qf_node);
1130 INIT_LIST_HEAD(&cmd->se_cmd_list);
1131 INIT_LIST_HEAD(&cmd->state_list);
1132 init_completion(&cmd->t_transport_stop_comp);
1133 init_completion(&cmd->cmd_wait_comp);
1134 init_completion(&cmd->task_stop_comp);
1135 spin_lock_init(&cmd->t_state_lock);
1136 kref_init(&cmd->cmd_kref);
1137 cmd->transport_state = CMD_T_DEV_ACTIVE;
1139 cmd->se_tfo = tfo;
1140 cmd->se_sess = se_sess;
1141 cmd->data_length = data_length;
1142 cmd->data_direction = data_direction;
1143 cmd->sam_task_attr = task_attr;
1144 cmd->sense_buffer = sense_buffer;
1146 cmd->state_active = false;
1151 transport_check_alloc_task_attr(struct se_cmd *cmd)
1153 struct se_device *dev = cmd->se_dev;
1162 if (cmd->sam_task_attr == MSG_ACA_TAG) {
1171 cmd->se_ordered_id = atomic_inc_return(&dev->dev_ordered_id);
1173 cmd->se_ordered_id, cmd->sam_task_attr,
1179 target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb)
1181 struct se_device *dev = cmd->se_dev;
1199 if (scsi_command_size(cdb) > sizeof(cmd->__t_task_cdb)) {
1200 cmd->t_task_cdb = kzalloc(scsi_command_size(cdb),
1202 if (!cmd->t_task_cdb) {
1203 pr_err("Unable to allocate cmd->t_task_cdb"
1204 " %u > sizeof(cmd->__t_task_cdb): %lu ops\n",
1206 (unsigned long)sizeof(cmd->__t_task_cdb));
1210 cmd->t_task_cdb = &cmd->__t_task_cdb[0];
1212 * Copy the original CDB into cmd->
1214 memcpy(cmd->t_task_cdb, cdb, scsi_command_size(cdb));
1216 trace_target_sequencer_start(cmd);
1221 ret = target_scsi3_ua_check(cmd);
1225 ret = target_alua_state_check(cmd);
1229 ret = target_check_reservation(cmd);
1231 cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT;
1235 ret = dev->transport->parse_cdb(cmd);
1239 ret = transport_check_alloc_task_attr(cmd);
1243 cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE;
1245 spin_lock(&cmd->se_lun->lun_sep_lock);
1246 if (cmd->se_lun->lun_sep)
1247 cmd->se_lun->lun_sep->sep_stats.cmd_pdus++;
1248 spin_unlock(&cmd->se_lun->lun_sep_lock);
1258 struct se_cmd *cmd)
1262 if (!cmd->se_lun) {
1264 pr_err("cmd->se_lun is NULL\n");
1278 * Also, we don't take cmd->t_state_lock here as we only expect
1281 cmd->t_state = TRANSPORT_NEW_CMD;
1282 cmd->transport_state |= CMD_T_ACTIVE;
1289 ret = transport_generic_new_cmd(cmd);
1291 transport_generic_request_failure(cmd, ret);
1297 transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
1308 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
1314 cmd->t_data_sg = sgl;
1315 cmd->t_data_nents = sgl_count;
1318 cmd->t_bidi_data_sg = sgl_bidi;
1319 cmd->t_bidi_data_nents = sgl_bidi_count;
1321 cmd->se_cmd_flags |= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC;
1377 * Obtain struct se_cmd->cmd_kref reference and add new cmd to
1517 * @flags: submit cmd flags
1569 * If the cmd is active, request it to be stopped and sleep until it
1572 bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags)
1576 if (cmd->transport_state & CMD_T_BUSY) {
1577 cmd->transport_state |= CMD_T_REQUEST_STOP;
1578 spin_unlock_irqrestore(&cmd->t_state_lock, *flags);
1580 pr_debug("cmd %p waiting to complete\n", cmd);
1581 wait_for_completion(&cmd->task_stop_comp);
1582 pr_debug("cmd %p stopped successfully\n", cmd);
1584 spin_lock_irqsave(&cmd->t_state_lock, *flags);
1585 cmd->transport_state &= ~CMD_T_REQUEST_STOP;
1586 cmd->transport_state &= ~CMD_T_BUSY;
1596 void transport_generic_request_failure(struct se_cmd *cmd,
1601 pr_debug("-----[ Storage Engine Exception for cmd: %p ITT: 0x%08x"
1602 " CDB: 0x%02x\n", cmd, cmd->se_tfo->get_task_tag(cmd),
1603 cmd->t_task_cdb[0]);
1605 cmd->se_tfo->get_cmd_state(cmd),
1606 cmd->t_state, sense_reason);
1608 (cmd->transport_state & CMD_T_ACTIVE) != 0,
1609 (cmd->transport_state & CMD_T_STOP) != 0,
1610 (cmd->transport_state & CMD_T_SENT) != 0);
1615 transport_complete_task_attr(cmd);
1620 if ((cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE) &&
1621 cmd->transport_complete_callback)
1622 cmd->transport_complete_callback(cmd);
1651 cmd->scsi_status = SAM_STAT_RESERVATION_CONFLICT;
1659 if (cmd->se_sess &&
1660 cmd->se_dev->dev_attrib.emulate_ua_intlck_ctrl == 2)
1661 core_scsi3_ua_allocate(cmd->se_sess->se_node_acl,
1662 cmd->orig_fe_lun, 0x2C,
1665 trace_target_cmd_complete(cmd);
1666 ret = cmd->se_tfo-> queue_status(cmd);
1672 cmd->t_task_cdb[0], sense_reason);
1677 ret = transport_send_check_condition_and_sense(cmd, sense_reason, 0);
1682 transport_lun_remove_cmd(cmd);
1683 if (!transport_cmd_check_stop_to_fabric(cmd))
1688 cmd->t_state = TRANSPORT_COMPLETE_QF_OK;
1689 transport_handle_queue_full(cmd, cmd->se_dev);
1693 void __target_execute_cmd(struct se_cmd *cmd)
1697 if (cmd->execute_cmd) {
1698 ret = cmd->execute_cmd(cmd);
1700 spin_lock_irq(&cmd->t_state_lock);
1701 cmd->transport_state &= ~(CMD_T_BUSY|CMD_T_SENT);
1702 spin_unlock_irq(&cmd->t_state_lock);
1704 transport_generic_request_failure(cmd, ret);
1709 static bool target_handle_task_attr(struct se_cmd *cmd)
1711 struct se_device *dev = cmd->se_dev;
1720 switch (cmd->sam_task_attr) {
1724 cmd->t_task_cdb[0], cmd->se_ordered_id);
1731 cmd->t_task_cdb[0], cmd->se_ordered_id);
1752 list_add_tail(&cmd->se_delayed_node, &dev->delayed_cmd_list);
1757 cmd->t_task_cdb[0], cmd->sam_task_attr,
1758 cmd->se_ordered_id);
1762 void target_execute_cmd(struct se_cmd *cmd)
1767 if (transport_check_aborted_status(cmd, 1))
1774 spin_lock_irq(&cmd->t_state_lock);
1775 if (cmd->transport_state & CMD_T_STOP) {
1778 cmd->se_tfo->get_task_tag(cmd));
1780 spin_unlock_irq(&cmd->t_state_lock);
1781 complete_all(&cmd->t_transport_stop_comp);
1785 cmd->t_state = TRANSPORT_PROCESSING;
1786 cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT;
1787 spin_unlock_irq(&cmd->t_state_lock);
1793 if (cmd->prot_op == TARGET_PROT_DOUT_INSERT) {
1794 if (!(cmd->se_sess->sup_prot_ops & TARGET_PROT_DOUT_INSERT))
1795 sbc_dif_generate(cmd);
1798 if (target_handle_task_attr(cmd)) {
1799 spin_lock_irq(&cmd->t_state_lock);
1800 cmd->transport_state &= ~CMD_T_BUSY|CMD_T_SENT;
1801 spin_unlock_irq(&cmd->t_state_lock);
1805 __target_execute_cmd(cmd);
1816 struct se_cmd *cmd;
1824 cmd = list_entry(dev->delayed_cmd_list.next,
1826 list_del(&cmd->se_delayed_node);
1829 __target_execute_cmd(cmd);
1831 if (cmd->sam_task_attr == MSG_ORDERED_TAG)
1840 static void transport_complete_task_attr(struct se_cmd *cmd)
1842 struct se_device *dev = cmd->se_dev;
1847 if (cmd->sam_task_attr == MSG_SIMPLE_TAG) {
1852 cmd->se_ordered_id);
1853 } else if (cmd->sam_task_attr == MSG_HEAD_TAG) {
1857 cmd->se_ordered_id);
1858 } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) {
1863 " %u\n", dev->dev_cur_ordered_id, cmd->se_ordered_id);
1869 static void transport_complete_qf(struct se_cmd *cmd)
1873 transport_complete_task_attr(cmd);
1875 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) {
1876 trace_target_cmd_complete(cmd);
1877 ret = cmd->se_tfo->queue_status(cmd);
1881 switch (cmd->data_direction) {
1883 trace_target_cmd_complete(cmd);
1884 ret = cmd->se_tfo->queue_data_in(cmd);
1887 if (cmd->se_cmd_flags & SCF_BIDI) {
1888 ret = cmd->se_tfo->queue_data_in(cmd);
1894 trace_target_cmd_complete(cmd);
1895 ret = cmd->se_tfo->queue_status(cmd);
1903 transport_handle_queue_full(cmd, cmd->se_dev);
1906 transport_lun_remove_cmd(cmd);
1907 transport_cmd_check_stop_to_fabric(cmd);
1911 struct se_cmd *cmd,
1915 list_add_tail(&cmd->se_qf_node, &cmd->se_dev->qf_cmd_list);
1917 spin_unlock_irq(&cmd->se_dev->qf_cmd_lock);
1919 schedule_work(&cmd->se_dev->qf_work_queue);
1922 static bool target_check_read_strip(struct se_cmd *cmd)
1926 if (!(cmd->se_sess->sup_prot_ops & TARGET_PROT_DIN_STRIP)) {
1927 rc = sbc_dif_read_strip(cmd);
1929 cmd->pi_err = rc;
1939 struct se_cmd *cmd = container_of(work, struct se_cmd, work);
1947 transport_complete_task_attr(cmd);
1951 * cmd->transport_qf_callback()
1953 if (atomic_read(&cmd->se_dev->dev_qf_count) != 0)
1954 schedule_work(&cmd->se_dev->qf_work_queue);
1960 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) {
1961 WARN_ON(!cmd->scsi_status);
1963 cmd, 0, 1);
1967 transport_lun_remove_cmd(cmd);
1968 transport_cmd_check_stop_to_fabric(cmd);
1975 if (cmd->transport_complete_callback) {
1978 rc = cmd->transport_complete_callback(cmd);
1979 if (!rc && !(cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE_POST)) {
1982 ret = transport_send_check_condition_and_sense(cmd,
1987 transport_lun_remove_cmd(cmd);
1988 transport_cmd_check_stop_to_fabric(cmd);
1993 switch (cmd->data_direction) {
1995 spin_lock(&cmd->se_lun->lun_sep_lock);
1996 if (cmd->se_lun->lun_sep) {
1997 cmd->se_lun->lun_sep->sep_stats.tx_data_octets +=
1998 cmd->data_length;
2000 spin_unlock(&cmd->se_lun->lun_sep_lock);
2006 if (cmd->prot_op == TARGET_PROT_DIN_STRIP &&
2007 target_check_read_strip(cmd)) {
2008 ret = transport_send_check_condition_and_sense(cmd,
2009 cmd->pi_err, 0);
2013 transport_lun_remove_cmd(cmd);
2014 transport_cmd_check_stop_to_fabric(cmd);
2018 trace_target_cmd_complete(cmd);
2019 ret = cmd->se_tfo->queue_data_in(cmd);
2024 spin_lock(&cmd->se_lun->lun_sep_lock);
2025 if (cmd->se_lun->lun_sep) {
2026 cmd->se_lun->lun_sep->sep_stats.rx_data_octets +=
2027 cmd->data_length;
2029 spin_unlock(&cmd->se_lun->lun_sep_lock);
2033 if (cmd->se_cmd_flags & SCF_BIDI) {
2034 spin_lock(&cmd->se_lun->lun_sep_lock);
2035 if (cmd->se_lun->lun_sep) {
2036 cmd->se_lun->lun_sep->sep_stats.tx_data_octets +=
2037 cmd->data_length;
2039 spin_unlock(&cmd->se_lun->lun_sep_lock);
2040 ret = cmd->se_tfo->queue_data_in(cmd);
2047 trace_target_cmd_complete(cmd);
2048 ret = cmd->se_tfo->queue_status(cmd);
2056 transport_lun_remove_cmd(cmd);
2057 transport_cmd_check_stop_to_fabric(cmd);
2062 " data_direction: %d\n", cmd, cmd->data_direction);
2063 cmd->t_state = TRANSPORT_COMPLETE_QF_OK;
2064 transport_handle_queue_full(cmd, cmd->se_dev);
2078 static inline void transport_reset_sgl_orig(struct se_cmd *cmd)
2084 if (!cmd->t_data_sg_orig)
2087 kfree(cmd->t_data_sg);
2088 cmd->t_data_sg = cmd->t_data_sg_orig;
2089 cmd->t_data_sg_orig = NULL;
2090 cmd->t_data_nents = cmd->t_data_nents_orig;
2091 cmd->t_data_nents_orig = 0;
2094 static inline void transport_free_pages(struct se_cmd *cmd)
2096 if (cmd->se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) {
2097 transport_reset_sgl_orig(cmd);
2100 transport_reset_sgl_orig(cmd);
2102 transport_free_sgl(cmd->t_data_sg, cmd->t_data_nents);
2103 cmd->t_data_sg = NULL;
2104 cmd->t_data_nents = 0;
2106 transport_free_sgl(cmd->t_bidi_data_sg, cmd->t_bidi_data_nents);
2107 cmd->t_bidi_data_sg = NULL;
2108 cmd->t_bidi_data_nents = 0;
2110 transport_free_sgl(cmd->t_prot_sg, cmd->t_prot_nents);
2111 cmd->t_prot_sg = NULL;
2112 cmd->t_prot_nents = 0;
2117 * @cmd: command to free
2122 static int transport_release_cmd(struct se_cmd *cmd)
2124 BUG_ON(!cmd->se_tfo);
2126 if (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)
2127 core_tmr_release_req(cmd->se_tmr_req);
2128 if (cmd->t_task_cdb != cmd->__t_task_cdb)
2129 kfree(cmd->t_task_cdb);
2131 * If this cmd has been setup with target_get_sess_cmd(), drop
2134 return target_put_sess_cmd(cmd->se_sess, cmd);
2139 * @cmd: command to release
2143 static int transport_put_cmd(struct se_cmd *cmd)
2145 transport_free_pages(cmd);
2146 return transport_release_cmd(cmd);
2149 void *transport_kmap_data_sg(struct se_cmd *cmd)
2151 struct scatterlist *sg = cmd->t_data_sg;
2160 if (!cmd->t_data_nents)
2164 if (cmd->t_data_nents == 1)
2168 pages = kmalloc(sizeof(*pages) * cmd->t_data_nents, GFP_KERNEL);
2173 for_each_sg(cmd->t_data_sg, sg, cmd->t_data_nents, i) {
2177 cmd->t_data_vmap = vmap(pages, cmd->t_data_nents, VM_MAP, PAGE_KERNEL);
2179 if (!cmd->t_data_vmap)
2182 return cmd->t_data_vmap + cmd->t_data_sg[0].offset;
2186 void transport_kunmap_data_sg(struct se_cmd *cmd)
2188 if (!cmd->t_data_nents) {
2190 } else if (cmd->t_data_nents == 1) {
2191 kunmap(sg_page(cmd->t_data_sg));
2195 vunmap(cmd->t_data_vmap);
2196 cmd->t_data_vmap = NULL;
2246 transport_generic_new_cmd(struct se_cmd *cmd)
2255 if (!(cmd->se_cmd_flags & SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC) &&
2256 cmd->data_length) {
2257 bool zero_flag = !(cmd->se_cmd_flags & SCF_SCSI_DATA_CDB);
2259 if ((cmd->se_cmd_flags & SCF_BIDI) ||
2260 (cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE)) {
2263 if (cmd->se_cmd_flags & SCF_COMPARE_AND_WRITE)
2264 bidi_length = cmd->t_task_nolb *
2265 cmd->se_dev->dev_attrib.block_size;
2267 bidi_length = cmd->data_length;
2269 ret = target_alloc_sgl(&cmd->t_bidi_data_sg,
2270 &cmd->t_bidi_data_nents,
2276 if (cmd->prot_op != TARGET_PROT_NORMAL) {
2277 ret = target_alloc_sgl(&cmd->t_prot_sg,
2278 &cmd->t_prot_nents,
2279 cmd->prot_length, true);
2284 ret = target_alloc_sgl(&cmd->t_data_sg, &cmd->t_data_nents,
2285 cmd->data_length, zero_flag);
2294 target_add_to_state_list(cmd);
2295 if (cmd->data_direction != DMA_TO_DEVICE || cmd->data_length == 0) {
2296 target_execute_cmd(cmd);
2299 transport_cmd_check_stop(cmd, false, true);
2301 ret = cmd->se_tfo->write_pending(cmd);
2311 pr_debug("Handling write_pending QUEUE__FULL: se_cmd: %p\n", cmd);
2312 cmd->t_state = TRANSPORT_COMPLETE_QF_WP;
2313 transport_handle_queue_full(cmd, cmd->se_dev);
2318 static void transport_write_pending_qf(struct se_cmd *cmd)
2322 ret = cmd->se_tfo->write_pending(cmd);
2325 cmd);
2326 transport_handle_queue_full(cmd, cmd->se_dev);
2330 int transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)
2335 if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD)) {
2336 if (wait_for_tasks && (cmd->se_cmd_flags & SCF_SCSI_TMR_CDB))
2337 transport_wait_for_tasks(cmd);
2339 ret = transport_release_cmd(cmd);
2342 transport_wait_for_tasks(cmd);
2348 if (cmd->state_active) {
2349 spin_lock_irqsave(&cmd->t_state_lock, flags);
2350 target_remove_from_state_list(cmd);
2351 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2354 if (cmd->se_lun)
2355 transport_lun_remove_cmd(cmd);
2357 ret = transport_put_cmd(cmd);
2517 * @cmd: command to wait
2522 bool transport_wait_for_tasks(struct se_cmd *cmd)
2526 spin_lock_irqsave(&cmd->t_state_lock, flags);
2527 if (!(cmd->se_cmd_flags & SCF_SE_LUN_CMD) &&
2528 !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
2529 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2533 if (!(cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE) &&
2534 !(cmd->se_cmd_flags & SCF_SCSI_TMR_CDB)) {
2535 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2539 if (!(cmd->transport_state & CMD_T_ACTIVE)) {
2540 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2544 cmd->transport_state |= CMD_T_STOP;
2548 cmd, cmd->se_tfo->get_task_tag(cmd),
2549 cmd->se_tfo->get_cmd_state(cmd), cmd->t_state);
2551 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2553 wait_for_completion(&cmd->t_transport_stop_comp);
2555 spin_lock_irqsave(&cmd->t_state_lock, flags);
2556 cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP);
2559 "&cmd->t_transport_stop_comp) for ITT: 0x%08x\n",
2560 cmd->se_tfo->get_task_tag(cmd));
2562 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2569 struct se_cmd *cmd,
2573 *asc = cmd->scsi_asc;
2574 *ascq = cmd->scsi_ascq;
2593 transport_send_check_condition_and_sense(struct se_cmd *cmd,
2596 unsigned char *buffer = cmd->sense_buffer;
2600 spin_lock_irqsave(&cmd->t_state_lock, flags);
2601 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
2602 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2605 cmd->se_cmd_flags |= SCF_SENT_CHECK_CONDITION;
2606 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2612 cmd->se_cmd_flags |= SCF_EMULATED_TASK_SENSE;
2762 core_scsi3_ua_for_check_condition(cmd, &asc, &ascq);
2772 transport_get_sense_codes(cmd, &asc, &ascq);
2794 transport_err_sector_info(buffer, cmd->bad_sector);
2805 transport_err_sector_info(buffer, cmd->bad_sector);
2816 transport_err_sector_info(buffer, cmd->bad_sector);
2837 cmd->scsi_status = SAM_STAT_CHECK_CONDITION;
2842 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER;
2845 trace_target_cmd_complete(cmd);
2846 return cmd->se_tfo->queue_status(cmd);
2850 int transport_check_aborted_status(struct se_cmd *cmd, int send_status)
2852 if (!(cmd->transport_state & CMD_T_ABORTED))
2856 * If cmd has been aborted but either no status is to be sent or it has
2859 if (!send_status || !(cmd->se_cmd_flags & SCF_SEND_DELAYED_TAS))
2863 cmd->t_task_cdb[0], cmd->se_tfo->get_task_tag(cmd));
2865 cmd->se_cmd_flags &= ~SCF_SEND_DELAYED_TAS;
2866 cmd->scsi_status = SAM_STAT_TASK_ABORTED;
2867 trace_target_cmd_complete(cmd);
2868 cmd->se_tfo->queue_status(cmd);
2874 void transport_send_task_abort(struct se_cmd *cmd)
2878 spin_lock_irqsave(&cmd->t_state_lock, flags);
2879 if (cmd->se_cmd_flags & (SCF_SENT_CHECK_CONDITION)) {
2880 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2883 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2891 if (cmd->data_direction == DMA_TO_DEVICE) {
2892 if (cmd->se_tfo->write_pending_status(cmd) != 0) {
2893 cmd->transport_state |= CMD_T_ABORTED;
2894 cmd->se_cmd_flags |= SCF_SEND_DELAYED_TAS;
2898 cmd->scsi_status = SAM_STAT_TASK_ABORTED;
2900 transport_lun_remove_cmd(cmd);
2903 " ITT: 0x%08x\n", cmd->t_task_cdb[0],
2904 cmd->se_tfo->get_task_tag(cmd));
2906 trace_target_cmd_complete(cmd);
2907 cmd->se_tfo->queue_status(cmd);
2912 struct se_cmd *cmd = container_of(work, struct se_cmd, work);
2913 struct se_device *dev = cmd->se_dev;
2914 struct se_tmr_req *tmr = cmd->se_tmr_req;
2919 core_tmr_abort_task(dev, tmr, cmd->se_sess);
2944 cmd->t_state = TRANSPORT_ISTATE_PROCESSING;
2945 cmd->se_tfo->queue_tm_rsp(cmd);
2947 transport_cmd_check_stop_to_fabric(cmd);
2951 struct se_cmd *cmd)
2955 spin_lock_irqsave(&cmd->t_state_lock, flags);
2956 cmd->transport_state |= CMD_T_ACTIVE;
2957 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2959 INIT_WORK(&cmd->work, target_tmr_work);
2960 queue_work(cmd->se_dev->tmr_wq, &cmd->work);