Lines Matching refs:cmd
497 static int iscsit_queue_rsp(struct iscsi_conn *conn, struct iscsi_cmd *cmd)
499 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
503 static void iscsit_aborted_task(struct iscsi_conn *conn, struct iscsi_cmd *cmd)
505 bool scsi_cmd = (cmd->iscsi_opcode == ISCSI_OP_SCSI_CMD);
508 if (!list_empty(&cmd->i_conn_node))
509 list_del_init(&cmd->i_conn_node);
512 __iscsit_free_cmd(cmd, scsi_cmd, true);
651 struct iscsi_cmd *cmd;
653 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
654 if (!cmd)
657 cmd->iscsi_opcode = ISCSI_OP_REJECT;
658 cmd->reject_reason = reason;
660 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
661 if (!cmd->buf_ptr) {
662 pr_err("Unable to allocate memory for cmd->buf_ptr\n");
663 iscsit_free_cmd(cmd, false);
668 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
671 cmd->i_state = ISTATE_SEND_REJECT;
672 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
678 struct iscsi_cmd *cmd,
685 if (!cmd->conn) {
686 pr_err("cmd->conn is NULL for ITT: 0x%08x\n",
687 cmd->init_task_tag);
690 conn = cmd->conn;
692 cmd->iscsi_opcode = ISCSI_OP_REJECT;
693 cmd->reject_reason = reason;
695 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
696 if (!cmd->buf_ptr) {
697 pr_err("Unable to allocate memory for cmd->buf_ptr\n");
698 iscsit_free_cmd(cmd, false);
704 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
708 cmd->i_state = ISTATE_SEND_REJECT;
709 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
714 if (cmd->se_cmd.se_tfo != NULL) {
716 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
721 static int iscsit_add_reject_cmd(struct iscsi_cmd *cmd, u8 reason,
724 return iscsit_add_reject_from_cmd(cmd, reason, true, buf);
727 int iscsit_reject_cmd(struct iscsi_cmd *cmd, u8 reason, unsigned char *buf)
729 return iscsit_add_reject_from_cmd(cmd, reason, false, buf);
737 struct iscsi_cmd *cmd,
749 sg = &cmd->se_cmd.t_data_sg[data_offset / PAGE_SIZE];
752 cmd->first_data_sg = sg;
753 cmd->first_data_sg_off = page_off;
767 cmd->kmapped_nents = i;
772 static void iscsit_unmap_iovec(struct iscsi_cmd *cmd)
777 sg = cmd->first_data_sg;
779 for (i = 0; i < cmd->kmapped_nents; i++)
786 struct iscsi_cmd *cmd, *cmd_p;
794 list_for_each_entry_safe(cmd, cmd_p, &conn->conn_cmd_list, i_conn_node) {
795 spin_lock(&cmd->istate_lock);
796 if ((cmd->i_state == ISTATE_SENT_STATUS) &&
797 iscsi_sna_lt(cmd->stat_sn, exp_statsn)) {
798 cmd->i_state = ISTATE_REMOVE;
799 spin_unlock(&cmd->istate_lock);
800 list_move_tail(&cmd->i_conn_node, &ack_list);
803 spin_unlock(&cmd->istate_lock);
807 list_for_each_entry_safe(cmd, cmd_p, &ack_list, i_conn_node) {
808 list_del_init(&cmd->i_conn_node);
809 iscsit_free_cmd(cmd, false);
813 static int iscsit_allocate_iovecs(struct iscsi_cmd *cmd)
815 u32 iov_count = max(1UL, DIV_ROUND_UP(cmd->se_cmd.data_length, PAGE_SIZE));
819 cmd->iov_data = kzalloc(iov_count * sizeof(struct kvec), GFP_KERNEL);
820 if (!cmd->iov_data) {
821 pr_err("Unable to allocate cmd->iov_data\n");
825 cmd->orig_iov_data_count = iov_count;
829 int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
848 return iscsit_add_reject_cmd(cmd,
877 return iscsit_add_reject_cmd(cmd,
884 return iscsit_add_reject_cmd(cmd,
891 return iscsit_add_reject_cmd(cmd,
898 return iscsit_add_reject_cmd(cmd,
907 return iscsit_add_reject_cmd(cmd,
915 return iscsit_add_reject_cmd(cmd,
923 return iscsit_add_reject_cmd(cmd,
931 return iscsit_add_reject_cmd(cmd,
939 cmd->data_direction = data_direction;
959 cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD;
960 cmd->i_state = ISTATE_NEW_CMD;
961 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
962 cmd->immediate_data = (payload_length) ? 1 : 0;
963 cmd->unsolicited_data = ((!(hdr->flags & ISCSI_FLAG_CMD_FINAL) &&
965 if (cmd->unsolicited_data)
966 cmd->cmd_flags |= ICF_NON_IMMEDIATE_UNSOLICITED_DATA;
968 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
971 cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
972 if (cmd->targ_xfer_tag == 0xFFFFFFFF)
973 cmd->targ_xfer_tag = conn->sess->targ_xfer_tag++;
976 cmd->targ_xfer_tag = 0xFFFFFFFF;
977 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
978 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
979 cmd->first_burst_len = payload_length;
982 cmd->data_direction == DMA_FROM_DEVICE) {
987 return iscsit_add_reject_cmd(cmd,
990 iscsit_attach_datain_req(cmd, dr);
996 transport_init_se_cmd(&cmd->se_cmd, &lio_target_fabric_configfs->tf_ops,
998 cmd->data_direction, sam_task_attr,
999 cmd->sense_buffer + 2);
1006 target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
1008 cmd->sense_reason = transport_lookup_cmd_lun(&cmd->se_cmd,
1010 if (cmd->sense_reason)
1013 cmd->sense_reason = target_setup_cmd_from_cdb(&cmd->se_cmd, hdr->cdb);
1014 if (cmd->sense_reason) {
1015 if (cmd->sense_reason == TCM_OUT_OF_RESOURCES) {
1016 return iscsit_add_reject_cmd(cmd,
1023 if (iscsit_build_pdu_and_seq_lists(cmd, payload_length) < 0) {
1024 return iscsit_add_reject_cmd(cmd,
1030 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1036 core_alua_check_nonop_delay(&cmd->se_cmd);
1042 void iscsit_set_unsoliticed_dataout(struct iscsi_cmd *cmd)
1044 iscsit_set_dataout_sequence_values(cmd);
1046 spin_lock_bh(&cmd->dataout_timeout_lock);
1047 iscsit_start_dataout_timer(cmd, cmd->conn);
1048 spin_unlock_bh(&cmd->dataout_timeout_lock);
1052 int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1066 if (!cmd->immediate_data) {
1067 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1072 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1082 if (!cmd->immediate_data) {
1083 if (!cmd->sense_reason && cmd->unsolicited_data)
1084 iscsit_set_unsoliticed_dataout(cmd);
1085 if (!cmd->sense_reason)
1088 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1097 if (cmd->sense_reason) {
1098 if (cmd->reject_reason)
1107 cmd->sense_reason = transport_generic_new_cmd(&cmd->se_cmd);
1108 if (cmd->sense_reason)
1116 iscsit_get_immediate_data(struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr,
1119 struct iscsi_conn *conn = cmd->conn;
1127 immed_ret = iscsit_handle_immediate_data(cmd, hdr,
1128 cmd->first_burst_len);
1136 cmdsn_ret = iscsit_sequence_cmd(cmd->conn, cmd,
1141 if (cmd->sense_reason || cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
1144 rc = iscsit_dump_data_payload(cmd->conn,
1145 cmd->first_burst_len, 1);
1146 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1148 } else if (cmd->unsolicited_data)
1149 iscsit_set_unsoliticed_dataout(cmd);
1163 cmd->i_state = ISTATE_REMOVE;
1164 iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, cmd->i_state);
1172 iscsit_handle_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1179 rc = iscsit_setup_scsi_cmd(conn, cmd, buf);
1186 if (iscsit_allocate_iovecs(cmd) < 0) {
1187 return iscsit_add_reject_cmd(cmd,
1190 immed_data = cmd->immediate_data;
1192 rc = iscsit_process_scsi_cmd(conn, cmd, hdr);
1201 return iscsit_get_immediate_data(cmd, hdr, dump_payload);
1206 struct iscsi_cmd *cmd,
1219 sg = cmd->first_data_sg;
1220 page_off = cmd->first_data_sg_off;
1271 struct iscsi_cmd *cmd = NULL;
1292 cmd = iscsit_find_cmd_from_itt_or_dump(conn, hdr->itt,
1294 if (!cmd)
1302 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
1305 cmd->init_task_tag);
1309 if (cmd->data_direction != DMA_TO_DEVICE) {
1311 " NON-WRITE command.\n", cmd->init_task_tag);
1314 se_cmd = &cmd->se_cmd;
1315 iscsit_mod_dataout_timer(cmd);
1317 if ((be32_to_cpu(hdr->offset) + payload_length) > cmd->se_cmd.data_length) {
1320 hdr->offset, payload_length, cmd->se_cmd.data_length);
1321 return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_INVALID, buf);
1324 if (cmd->unsolicited_data) {
1330 transport_send_check_condition_and_sense(&cmd->se_cmd,
1352 iscsit_stop_dataout_timer(cmd);
1371 if (--cmd->outstanding_r2ts < 1) {
1372 iscsit_stop_dataout_timer(cmd);
1384 rc = iscsit_check_pre_dataout(cmd, buf);
1390 *out_cmd = cmd;
1396 iscsit_get_dataout(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1405 iov = &cmd->iov_data[0];
1407 iov_ret = iscsit_map_iovec(cmd, iov, be32_to_cpu(hdr->offset),
1416 iov[iov_count].iov_base = cmd->pad_bytes;
1428 rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);
1430 iscsit_unmap_iovec(cmd);
1438 data_crc = iscsit_do_crypto_hash_sg(&conn->conn_rx_hash, cmd,
1441 cmd->pad_bytes);
1461 iscsit_check_dataout_payload(struct iscsi_cmd *cmd, struct iscsi_data *hdr,
1464 struct iscsi_conn *conn = cmd->conn;
1470 rc = iscsit_check_post_dataout(cmd, (unsigned char *)hdr, data_crc_failed);
1474 iscsit_set_dataout_sequence_values(cmd);
1475 conn->conn_transport->iscsit_get_dataout(conn, cmd, false);
1481 spin_lock_bh(&cmd->istate_lock);
1482 ooo_cmdsn = (cmd->cmd_flags & ICF_OOO_CMDSN);
1483 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
1484 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
1485 spin_unlock_bh(&cmd->istate_lock);
1487 iscsit_stop_dataout_timer(cmd);
1490 target_execute_cmd(&cmd->se_cmd);
1501 struct iscsi_cmd *cmd = NULL;
1506 rc = iscsit_check_dataout_hdr(conn, buf, &cmd);
1509 else if (!cmd)
1512 rc = iscsit_get_dataout(conn, cmd, hdr);
1518 return iscsit_check_dataout_payload(cmd, hdr, data_crc_failed);
1521 int iscsit_setup_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1528 if (!cmd)
1532 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1539 if (!cmd)
1543 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1552 if (!cmd)
1556 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1573 cmd->iscsi_opcode = ISCSI_OP_NOOP_OUT;
1574 cmd->i_state = ISTATE_SEND_NOPIN;
1575 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ?
1577 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
1578 cmd->targ_xfer_tag = 0xFFFFFFFF;
1579 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1580 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1581 cmd->data_direction = DMA_NONE;
1588 int iscsit_process_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1597 if (!cmd)
1602 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1608 iscsit_add_cmd_to_response_queue(cmd, conn,
1609 cmd->i_state);
1613 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1646 static int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1655 ret = iscsit_setup_nop_out(conn, cmd, hdr);
1673 iov = &cmd->iov_misc[0];
1681 iov[niov].iov_base = &cmd->pad_bytes;
1691 rx_got = rx_data(conn, &cmd->iov_misc[0], niov, rx_size);
1700 padding, cmd->pad_bytes,
1735 cmd->buf_ptr = ping_data;
1736 cmd->buf_ptr_size = payload_length;
1743 return iscsit_process_nop_out(conn, cmd, hdr);
1745 if (cmd)
1746 iscsit_free_cmd(cmd, false);
1753 iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1784 return iscsit_add_reject_cmd(cmd,
1791 cmd->data_direction = DMA_NONE;
1793 cmd->tmr_req = kzalloc(sizeof(struct iscsi_tmr_req), GFP_KERNEL);
1794 if (!cmd->tmr_req) {
1797 return iscsit_add_reject_cmd(cmd,
1811 transport_init_se_cmd(&cmd->se_cmd,
1814 MSG_SIMPLE_TAG, cmd->sense_buffer + 2);
1816 target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
1844 return iscsit_add_reject_cmd(cmd,
1848 ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req,
1851 return iscsit_add_reject_cmd(cmd,
1854 cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req;
1857 cmd->iscsi_opcode = ISCSI_OP_SCSI_TMFUNC;
1858 cmd->i_state = ISTATE_SEND_TASKMGTRSP;
1859 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
1860 cmd->init_task_tag = hdr->itt;
1861 cmd->targ_xfer_tag = 0xFFFFFFFF;
1862 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1863 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1864 se_tmr = cmd->se_cmd.se_tmr_req;
1865 tmr_req = cmd->tmr_req;
1870 ret = transport_lookup_tmr_lun(&cmd->se_cmd,
1880 se_tmr->response = iscsit_tmr_abort_task(cmd, buf);
1902 se_tmr->response = iscsit_tmr_task_reassign(cmd, buf);
1911 return iscsit_add_reject_cmd(cmd,
1926 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1930 int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
1946 return transport_generic_handle_tmr(&cmd->se_cmd);
1958 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1961 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
1968 iscsit_setup_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1977 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1984 return iscsit_reject_cmd(cmd, ISCSI_REASON_CMD_NOT_SUPPORTED,
1992 cmd->iscsi_opcode = ISCSI_OP_TEXT;
1993 cmd->i_state = ISTATE_SEND_TEXTRSP;
1994 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
1995 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
1996 cmd->targ_xfer_tag = 0xFFFFFFFF;
1997 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1998 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1999 cmd->data_direction = DMA_NONE;
2006 iscsit_process_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
2009 unsigned char *text_in = cmd->text_in_ptr, *text_ptr;
2029 cmd->cmd_flags |= IFC_SENDTARGETS_ALL;
2032 cmd->cmd_flags |= IFC_SENDTARGETS_SINGLE;
2039 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2045 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
2053 return iscsit_execute_cmd(cmd, 0);
2056 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
2062 iscsit_handle_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
2070 rc = iscsit_setup_text_cmd(conn, cmd, hdr);
2087 cmd->text_in_ptr = text_in;
2148 return iscsit_process_text_cmd(conn, cmd, hdr);
2151 kfree(cmd->text_in_ptr);
2152 cmd->text_in_ptr = NULL;
2153 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
2157 int iscsit_logout_closesession(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2182 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2187 int iscsit_logout_closeconnection(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2193 " %hu on CID: %hu.\n", cmd->logout_cid, conn->cid);
2199 if (conn->cid == cmd->logout_cid) {
2219 cmd->logout_cid);
2221 cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND;
2222 iscsit_add_cmd_to_response_queue(cmd, conn,
2223 cmd->i_state);
2230 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2235 int iscsit_logout_removeconnforrecovery(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2240 " CID: %hu on CID: %hu.\n", cmd->logout_cid, conn->cid);
2245 cmd->logout_response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED;
2246 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2250 if (conn->cid == cmd->logout_cid) {
2253 cmd->logout_cid, conn->cid);
2254 cmd->logout_response = ISCSI_LOGOUT_CLEANUP_FAILED;
2255 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2259 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2265 iscsit_handle_logout_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
2293 iscsit_free_cmd(cmd, false);
2297 cmd->iscsi_opcode = ISCSI_OP_LOGOUT;
2298 cmd->i_state = ISTATE_SEND_LOGOUTRSP;
2299 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
2300 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
2301 cmd->targ_xfer_tag = 0xFFFFFFFF;
2302 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
2303 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
2304 cmd->logout_cid = be16_to_cpu(hdr->cid);
2305 cmd->logout_reason = reason_code;
2306 cmd->data_direction = DMA_NONE;
2318 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2328 if (cmd->immediate_cmd) {
2329 int ret = iscsit_execute_cmd(cmd, 0);
2334 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
2410 struct iscsi_cmd *cmd,
2416 struct iscsi_conn *conn = cmd->conn;
2419 iov_ret = iscsit_map_iovec(cmd, cmd->iov_data, cmd->write_data_done, length);
2425 iov = &cmd->iov_data[0];
2429 iov[iov_count].iov_base = cmd->pad_bytes;
2440 rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);
2442 iscsit_unmap_iovec(cmd);
2452 data_crc = iscsit_do_crypto_hash_sg(&conn->conn_rx_hash, cmd,
2453 cmd->write_data_done, length, padding,
2454 cmd->pad_bytes);
2465 iscsit_reject_cmd(cmd,
2470 iscsit_reject_cmd(cmd,
2482 cmd->write_data_done += length;
2484 if (cmd->write_data_done == cmd->se_cmd.data_length) {
2485 spin_lock_bh(&cmd->istate_lock);
2486 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
2487 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
2488 spin_unlock_bh(&cmd->istate_lock);
2501 struct iscsi_cmd *cmd;
2520 cmd = iscsit_allocate_cmd(conn_p, TASK_RUNNING);
2521 if (!cmd) {
2526 cmd->logout_cid = conn->cid;
2527 cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT;
2528 cmd->i_state = ISTATE_SEND_ASYNCMSG;
2531 list_add_tail(&cmd->i_conn_node, &conn_p->conn_cmd_list);
2534 iscsit_add_cmd_to_response_queue(cmd, conn_p, cmd->i_state);
2539 struct iscsi_cmd *cmd,
2544 cmd->tx_size = ISCSI_HDR_LEN;
2545 cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT;
2547 hdr = (struct iscsi_async *) cmd->pdu;
2550 cmd->init_task_tag = RESERVED_ITT;
2551 cmd->targ_xfer_tag = 0xFFFFFFFF;
2553 cmd->stat_sn = conn->stat_sn++;
2554 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2558 hdr->param1 = cpu_to_be16(cmd->logout_cid);
2563 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
2568 cmd->tx_size += ISCSI_CRC_LEN;
2573 cmd->iov_misc[0].iov_base = cmd->pdu;
2574 cmd->iov_misc[0].iov_len = cmd->tx_size;
2575 cmd->iov_misc_count = 1;
2578 " 0x%08x, for CID: %hu on CID: %hu\n", cmd->stat_sn,
2579 cmd->logout_cid, conn->cid);
2594 iscsit_build_datain_pdu(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
2601 if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {
2603 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
2604 } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {
2606 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
2611 int_to_scsilun(cmd->se_cmd.orig_fe_lun,
2616 hdr->itt = cmd->init_task_tag;
2619 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
2623 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2634 cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn),
2638 static int iscsit_send_datain(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2640 struct iscsi_data_rsp *hdr = (struct iscsi_data_rsp *)&cmd->pdu[0];
2649 dr = iscsit_get_datain_values(cmd, &datain);
2652 cmd->init_task_tag);
2658 if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {
2660 " datain.length: %u exceeds cmd->data_length: %u\n",
2661 cmd->init_task_tag, datain.offset, datain.length,
2662 cmd->se_cmd.data_length);
2672 (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE))
2677 iscsit_increment_maxcmdsn(cmd, conn->sess);
2678 cmd->stat_sn = conn->stat_sn++;
2685 iscsit_build_datain_pdu(cmd, conn, &datain, hdr, set_statsn);
2687 iov = &cmd->iov_data[0];
2688 iov[iov_count].iov_base = cmd->pdu;
2693 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
2695 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, cmd->pdu,
2705 iov_ret = iscsit_map_iovec(cmd, &cmd->iov_data[1],
2713 cmd->padding = ((-datain.length) & 3);
2714 if (cmd->padding) {
2715 iov[iov_count].iov_base = cmd->pad_bytes;
2716 iov[iov_count++].iov_len = cmd->padding;
2717 tx_size += cmd->padding;
2720 cmd->padding);
2723 cmd->data_crc = iscsit_do_crypto_hash_sg(&conn->conn_tx_hash, cmd,
2724 datain.offset, datain.length, cmd->padding, cmd->pad_bytes);
2726 iov[iov_count].iov_base = &cmd->data_crc;
2731 " 0x%08x\n", datain.length+cmd->padding, cmd->data_crc);
2734 cmd->iov_data_count = iov_count;
2735 cmd->tx_size = tx_size;
2739 ret = iscsit_fe_sendpage_sg(cmd, conn);
2741 ret = iscsit_send_tx_data(cmd, conn, 0);
2743 iscsit_unmap_iovec(cmd);
2751 eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ?
2753 iscsit_free_datain_req(cmd, dr);
2760 iscsit_build_logout_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
2771 switch (cmd->logout_reason) {
2775 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2778 if (cmd->logout_response == ISCSI_LOGOUT_CID_NOT_FOUND)
2788 * on, the connection responding to cmd->logout_cid
2793 " successful.\n", cmd->logout_cid, conn->cid);
2794 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2797 if ((cmd->logout_response == ISCSI_LOGOUT_RECOVERY_UNSUPPORTED) ||
2798 (cmd->logout_response == ISCSI_LOGOUT_CLEANUP_FAILED))
2805 cmd->logout_cid);
2812 conn->sess, cmd->logout_cid);
2816 cmd->logout_cid);
2817 cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND;
2821 iscsit_discard_cr_cmds_by_expstatsn(cr, cmd->exp_stat_sn);
2825 cmd->logout_cid, conn->cid);
2826 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2829 pr_err("Unknown cmd->logout_reason: 0x%02x\n",
2830 cmd->logout_reason);
2836 hdr->response = cmd->logout_response;
2837 hdr->itt = cmd->init_task_tag;
2838 cmd->stat_sn = conn->stat_sn++;
2839 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2841 iscsit_increment_maxcmdsn(cmd, conn->sess);
2847 cmd->init_task_tag, cmd->stat_sn, hdr->response,
2848 cmd->logout_cid, conn->cid);
2855 iscsit_send_logout(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2860 rc = iscsit_build_logout_rsp(cmd, conn,
2861 (struct iscsi_logout_rsp *)&cmd->pdu[0]);
2866 iov = &cmd->iov_misc[0];
2867 iov[niov].iov_base = cmd->pdu;
2871 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
2873 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, &cmd->pdu[0],
2881 cmd->iov_misc_count = niov;
2882 cmd->tx_size = tx_size;
2888 iscsit_build_nopin_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
2893 hton24(hdr->dlength, cmd->buf_ptr_size);
2896 hdr->itt = cmd->init_task_tag;
2897 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
2898 cmd->stat_sn = (nopout_response) ? conn->stat_sn++ :
2900 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2903 iscsit_increment_maxcmdsn(cmd, conn->sess);
2910 "Solicitied" : "Unsolicitied", cmd->init_task_tag,
2911 cmd->targ_xfer_tag, cmd->stat_sn, cmd->buf_ptr_size);
2919 struct iscsi_cmd *cmd,
2923 struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
2926 iscsit_build_nopin_rsp(cmd, conn, hdr, false);
2929 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
2939 cmd->iov_misc[0].iov_base = cmd->pdu;
2940 cmd->iov_misc[0].iov_len = tx_size;
2941 cmd->iov_misc_count = 1;
2942 cmd->tx_size = tx_size;
2945 " 0x%08x CID: %hu\n", hdr->ttt, cmd->stat_sn, conn->cid);
2947 ret = iscsit_send_tx_data(cmd, conn, 1);
2953 spin_lock_bh(&cmd->istate_lock);
2954 cmd->i_state = want_response ?
2956 spin_unlock_bh(&cmd->istate_lock);
2962 iscsit_send_nopin(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2964 struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
2969 iscsit_build_nopin_rsp(cmd, conn, hdr, true);
2972 iov = &cmd->iov_misc[0];
2973 iov[niov].iov_base = cmd->pdu;
2977 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
2992 if (cmd->buf_ptr_size) {
2993 iov[niov].iov_base = cmd->buf_ptr;
2994 iov[niov++].iov_len = cmd->buf_ptr_size;
2995 tx_size += cmd->buf_ptr_size;
2998 " data.\n", cmd->buf_ptr_size);
3000 padding = ((-cmd->buf_ptr_size) & 3);
3002 iov[niov].iov_base = &cmd->pad_bytes;
3010 cmd->buf_ptr, cmd->buf_ptr_size,
3011 padding, (u8 *)&cmd->pad_bytes,
3012 (u8 *)&cmd->data_crc);
3014 iov[niov].iov_base = &cmd->data_crc;
3019 cmd->buf_ptr_size, cmd->data_crc);
3023 cmd->iov_misc_count = niov;
3024 cmd->tx_size = tx_size;
3030 struct iscsi_cmd *cmd,
3038 r2t = iscsit_get_r2t_from_list(cmd);
3042 hdr = (struct iscsi_r2t_rsp *) cmd->pdu;
3046 int_to_scsilun(cmd->se_cmd.orig_fe_lun,
3048 hdr->itt = cmd->init_task_tag;
3062 cmd->iov_misc[0].iov_base = cmd->pdu;
3063 cmd->iov_misc[0].iov_len = ISCSI_HDR_LEN;
3067 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
3072 cmd->iov_misc[0].iov_len += ISCSI_CRC_LEN;
3080 (!r2t->recovery_r2t) ? "" : "Recovery ", cmd->init_task_tag,
3084 cmd->iov_misc_count = 1;
3085 cmd->tx_size = tx_size;
3087 spin_lock_bh(&cmd->r2t_lock);
3089 spin_unlock_bh(&cmd->r2t_lock);
3091 ret = iscsit_send_tx_data(cmd, conn, 1);
3097 spin_lock_bh(&cmd->dataout_timeout_lock);
3098 iscsit_start_dataout_timer(cmd, conn);
3099 spin_unlock_bh(&cmd->dataout_timeout_lock);
3110 struct iscsi_cmd *cmd,
3116 spin_lock_bh(&cmd->r2t_lock);
3117 if (cmd->cmd_flags & ICF_SENT_LAST_R2T) {
3118 spin_unlock_bh(&cmd->r2t_lock);
3124 cmd->r2t_offset = max(cmd->r2t_offset, cmd->write_data_done);
3126 while (cmd->outstanding_r2ts < conn->sess->sess_ops->MaxOutstandingR2T) {
3128 offset = cmd->r2t_offset;
3133 cmd->next_burst_len;
3135 if (new_data_end > cmd->se_cmd.data_length)
3136 xfer_len = cmd->se_cmd.data_length - offset;
3140 cmd->next_burst_len;
3145 if (new_data_end > cmd->se_cmd.data_length)
3146 xfer_len = cmd->se_cmd.data_length - offset;
3150 cmd->r2t_offset += xfer_len;
3152 if (cmd->r2t_offset == cmd->se_cmd.data_length)
3153 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
3157 seq = iscsit_get_seq_holder_for_r2t(cmd);
3159 spin_unlock_bh(&cmd->r2t_lock);
3166 if (cmd->seq_send_order == cmd->seq_count)
3167 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
3169 cmd->outstanding_r2ts++;
3172 if (iscsit_add_r2t_to_list(cmd, offset, xfer_len, 0, 0) < 0) {
3173 spin_unlock_bh(&cmd->r2t_lock);
3177 if (cmd->cmd_flags & ICF_SENT_LAST_R2T)
3180 spin_unlock_bh(&cmd->r2t_lock);
3185 void iscsit_build_rsp_pdu(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3189 cmd->stat_sn = conn->stat_sn++;
3196 if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {
3198 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
3199 } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {
3201 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
3203 hdr->response = cmd->iscsi_response;
3204 hdr->cmd_status = cmd->se_cmd.scsi_status;
3205 hdr->itt = cmd->init_task_tag;
3206 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3208 iscsit_increment_maxcmdsn(cmd, conn->sess);
3214 cmd->init_task_tag, cmd->stat_sn, cmd->se_cmd.scsi_status,
3215 cmd->se_cmd.scsi_status, conn->cid);
3219 static int iscsit_send_response(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
3221 struct iscsi_scsi_rsp *hdr = (struct iscsi_scsi_rsp *)&cmd->pdu[0];
3225 bool inc_stat_sn = (cmd->i_state == ISTATE_SEND_STATUS);
3227 iscsit_build_rsp_pdu(cmd, conn, inc_stat_sn, hdr);
3229 iov = &cmd->iov_misc[0];
3230 iov[iov_count].iov_base = cmd->pdu;
3237 if (cmd->se_cmd.sense_buffer &&
3238 ((cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||
3239 (cmd->se_cmd.se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {
3240 put_unaligned_be16(cmd->se_cmd.scsi_sense_length, cmd->sense_buffer);
3241 cmd->se_cmd.scsi_sense_length += sizeof (__be16);
3243 padding = -(cmd->se_cmd.scsi_sense_length) & 3;
3244 hton24(hdr->dlength, (u32)cmd->se_cmd.scsi_sense_length);
3245 iov[iov_count].iov_base = cmd->sense_buffer;
3247 (cmd->se_cmd.scsi_sense_length + padding);
3248 tx_size += cmd->se_cmd.scsi_sense_length;
3251 memset(cmd->sense_buffer +
3252 cmd->se_cmd.scsi_sense_length, 0, padding);
3260 cmd->sense_buffer,
3261 (cmd->se_cmd.scsi_sense_length + padding),
3262 0, NULL, (u8 *)&cmd->data_crc);
3264 iov[iov_count].iov_base = &cmd->data_crc;
3270 (cmd->se_cmd.scsi_sense_length + padding),
3271 cmd->data_crc);
3276 cmd->se_cmd.scsi_sense_length);
3280 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
3282 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, cmd->pdu,
3291 cmd->iov_misc_count = iov_count;
3292 cmd->tx_size = tx_size;
3315 iscsit_build_task_mgt_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3318 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
3323 hdr->itt = cmd->init_task_tag;
3324 cmd->stat_sn = conn->stat_sn++;
3325 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3327 iscsit_increment_maxcmdsn(cmd, conn->sess);
3333 cmd->init_task_tag, cmd->stat_sn, hdr->response, conn->cid);
3338 iscsit_send_task_mgt_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
3340 struct iscsi_tm_rsp *hdr = (struct iscsi_tm_rsp *)&cmd->pdu[0];
3343 iscsit_build_task_mgt_rsp(cmd, conn, hdr);
3345 cmd->iov_misc[0].iov_base = cmd->pdu;
3346 cmd->iov_misc[0].iov_len = ISCSI_HDR_LEN;
3350 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
3355 cmd->iov_misc[0].iov_len += ISCSI_CRC_LEN;
3361 cmd->iov_misc_count = 1;
3362 cmd->tx_size = tx_size;
3394 iscsit_build_sendtargets_response(struct iscsi_cmd *cmd,
3398 struct iscsi_conn *conn = cmd->conn;
3405 unsigned char *text_in = cmd->text_in_ptr, *text_ptr = NULL;
3420 if (cmd->cmd_flags & IFC_SENDTARGETS_SINGLE) {
3436 if ((cmd->cmd_flags & IFC_SENDTARGETS_SINGLE) &&
3454 cmd->conn->sess->sess_ops->InitiatorName))) {
3514 if (cmd->cmd_flags & IFC_SENDTARGETS_SINGLE)
3519 cmd->buf_ptr = payload;
3525 iscsit_build_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3531 text_length = iscsit_build_sendtargets_response(cmd, network_transport);
3539 hdr->itt = cmd->init_task_tag;
3540 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
3541 cmd->stat_sn = conn->stat_sn++;
3542 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3544 iscsit_increment_maxcmdsn(cmd, conn->sess);
3549 " Length: %u, CID: %hu\n", cmd->init_task_tag, cmd->stat_sn,
3561 struct iscsi_cmd *cmd,
3564 struct iscsi_text_rsp *hdr = (struct iscsi_text_rsp *)cmd->pdu;
3569 rc = iscsit_build_text_rsp(cmd, conn, hdr, ISCSI_TCP);
3574 iov = &cmd->iov_misc[0];
3575 iov[iov_count].iov_base = cmd->pdu;
3577 iov[iov_count].iov_base = cmd->buf_ptr;
3583 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
3596 cmd->buf_ptr, text_length,
3597 0, NULL, (u8 *)&cmd->data_crc);
3599 iov[iov_count].iov_base = &cmd->data_crc;
3605 cmd->data_crc);
3608 cmd->iov_misc_count = iov_count;
3609 cmd->tx_size = tx_size;
3615 iscsit_build_reject(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3619 hdr->reason = cmd->reject_reason;
3623 cmd->stat_sn = conn->stat_sn++;
3624 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3632 struct iscsi_cmd *cmd,
3635 struct iscsi_reject *hdr = (struct iscsi_reject *)&cmd->pdu[0];
3639 iscsit_build_reject(cmd, conn, hdr);
3641 iov = &cmd->iov_misc[0];
3642 iov[iov_count].iov_base = cmd->pdu;
3644 iov[iov_count].iov_base = cmd->buf_ptr;
3650 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
3662 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, cmd->buf_ptr,
3663 ISCSI_HDR_LEN, 0, NULL, (u8 *)&cmd->data_crc);
3665 iov[iov_count].iov_base = &cmd->data_crc;
3669 " PDU 0x%08x\n", cmd->data_crc);
3672 cmd->iov_misc_count = iov_count;
3673 cmd->tx_size = tx_size;
3734 iscsit_immediate_queue(struct iscsi_conn *conn, struct iscsi_cmd *cmd, int state)
3740 ret = iscsit_send_r2t(cmd, conn);
3746 list_del_init(&cmd->i_conn_node);
3749 iscsit_free_cmd(cmd, false);
3753 ret = iscsit_send_unsolicited_nopin(cmd, conn, 1);
3758 ret = iscsit_send_unsolicited_nopin(cmd, conn, 0);
3765 cmd->iscsi_opcode, cmd->init_task_tag, state,
3781 struct iscsi_cmd *cmd;
3787 cmd = qr->cmd;
3791 ret = t->iscsit_immediate_queue(conn, cmd, state);
3800 iscsit_response_queue(struct iscsi_conn *conn, struct iscsi_cmd *cmd, int state)
3807 ret = iscsit_send_datain(cmd, conn);
3815 spin_lock_bh(&cmd->istate_lock);
3816 cmd->i_state = ISTATE_SENT_STATUS;
3817 spin_unlock_bh(&cmd->istate_lock);
3826 spin_lock_bh(&cmd->istate_lock);
3827 cmd->i_state = ISTATE_SEND_STATUS;
3828 spin_unlock_bh(&cmd->istate_lock);
3836 ret = iscsit_send_response(cmd, conn);
3839 ret = iscsit_send_logout(cmd, conn);
3843 cmd, conn);
3846 ret = iscsit_send_nopin(cmd, conn);
3849 ret = iscsit_send_reject(cmd, conn);
3852 ret = iscsit_send_task_mgt_rsp(cmd, conn);
3855 ret = iscsit_tmr_post_handler(cmd, conn);
3860 ret = iscsit_send_text_rsp(cmd, conn);
3865 cmd->iscsi_opcode, cmd->init_task_tag,
3872 if (iscsit_send_tx_data(cmd, conn, 1) < 0) {
3874 iscsit_unmap_iovec(cmd);
3877 iscsit_unmap_iovec(cmd);
3881 if (!iscsit_logout_post_handler(cmd, conn))
3891 spin_lock_bh(&cmd->istate_lock);
3892 cmd->i_state = ISTATE_SENT_STATUS;
3893 spin_unlock_bh(&cmd->istate_lock);
3898 cmd->iscsi_opcode, cmd->init_task_tag,
3899 cmd->i_state, conn->cid);
3918 struct iscsi_cmd *cmd;
3923 cmd = qr->cmd;
3927 ret = t->iscsit_response_queue(conn, cmd, state);
3992 struct iscsi_cmd *cmd;
3997 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
3998 if (!cmd)
4001 ret = iscsit_handle_scsi_cmd(conn, cmd, buf);
4007 cmd = NULL;
4009 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4010 if (!cmd)
4013 ret = iscsit_handle_nop_out(conn, cmd, buf);
4016 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4017 if (!cmd)
4020 ret = iscsit_handle_task_mgt_cmd(conn, cmd, buf);
4023 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4024 if (!cmd)
4027 ret = iscsit_handle_text_cmd(conn, cmd, buf);
4030 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4031 if (!cmd)
4034 ret = iscsit_handle_logout_cmd(conn, cmd, buf);
4179 struct iscsi_cmd *cmd = NULL, *cmd_tmp = NULL;
4187 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
4189 list_del_init(&cmd->i_conn_node);
4192 iscsit_increment_maxcmdsn(cmd, sess);
4194 iscsit_free_cmd(cmd, true);
4204 struct iscsi_cmd *cmd;
4207 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
4208 if (cmd->data_direction == DMA_TO_DEVICE)
4209 iscsit_stop_dataout_timer(cmd);
4573 struct iscsi_cmd *cmd,
4578 switch (cmd->logout_reason) {
4580 switch (cmd->logout_response) {
4590 if (conn->cid == cmd->logout_cid) {
4591 switch (cmd->logout_response) {
4600 switch (cmd->logout_response) {
4603 cmd->logout_cid);
4614 switch (cmd->logout_response) {