Lines Matching defs:cmd
476 int iscsit_queue_rsp(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
478 return iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
482 void iscsit_aborted_task(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
485 if (!list_empty(&cmd->i_conn_node))
486 list_del_init(&cmd->i_conn_node);
489 __iscsit_free_cmd(cmd, true);
498 iscsit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
501 struct iscsi_hdr *hdr = (struct iscsi_hdr *)cmd->pdu;
506 iov = &cmd->iov_misc[0];
507 iov[niov].iov_base = cmd->pdu;
511 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
532 iov[niov].iov_base = &cmd->pad_bytes;
542 padding, &cmd->pad_bytes,
543 &cmd->data_crc);
545 iov[niov].iov_base = &cmd->data_crc;
550 data_buf_len, hdr->opcode, cmd->data_crc);
554 cmd->iov_misc_count = niov;
555 cmd->tx_size = tx_size;
557 ret = iscsit_send_tx_data(cmd, conn, 1);
566 static int iscsit_map_iovec(struct iscsit_cmd *cmd, struct kvec *iov, int nvec,
572 iscsit_xmit_datain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
579 iov = &cmd->iov_data[0];
580 iov[iov_count].iov_base = cmd->pdu;
585 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
587 iscsit_do_crypto_hash_buf(conn->conn_tx_hash, cmd->pdu,
598 iov_ret = iscsit_map_iovec(cmd, &cmd->iov_data[iov_count],
599 cmd->orig_iov_data_count - (iov_count + 2),
607 cmd->padding = ((-datain->length) & 3);
608 if (cmd->padding) {
609 iov[iov_count].iov_base = cmd->pad_bytes;
610 iov[iov_count++].iov_len = cmd->padding;
611 tx_size += cmd->padding;
613 pr_debug("Attaching %u padding bytes\n", cmd->padding);
617 cmd->data_crc = iscsit_do_crypto_hash_sg(conn->conn_tx_hash,
618 cmd, datain->offset,
620 cmd->padding,
621 cmd->pad_bytes);
623 iov[iov_count].iov_base = &cmd->data_crc;
628 datain->length + cmd->padding, cmd->data_crc);
631 cmd->iov_data_count = iov_count;
632 cmd->tx_size = tx_size;
634 ret = iscsit_fe_sendpage_sg(cmd, conn);
636 iscsit_unmap_iovec(cmd);
646 static int iscsit_xmit_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
651 return iscsit_xmit_datain_pdu(conn, cmd, buf);
653 return iscsit_xmit_nondatain_pdu(conn, cmd, buf, buf_len);
802 struct iscsit_cmd *cmd;
804 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
805 if (!cmd)
808 cmd->iscsi_opcode = ISCSI_OP_REJECT;
809 cmd->reject_reason = reason;
811 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
812 if (!cmd->buf_ptr) {
813 pr_err("Unable to allocate memory for cmd->buf_ptr\n");
814 iscsit_free_cmd(cmd, false);
819 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
822 cmd->i_state = ISTATE_SEND_REJECT;
823 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
830 struct iscsit_cmd *cmd,
836 const bool do_put = cmd->se_cmd.se_tfo != NULL;
838 if (!cmd->conn) {
839 pr_err("cmd->conn is NULL for ITT: 0x%08x\n",
840 cmd->init_task_tag);
843 conn = cmd->conn;
845 cmd->iscsi_opcode = ISCSI_OP_REJECT;
846 cmd->reject_reason = reason;
848 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
849 if (!cmd->buf_ptr) {
850 pr_err("Unable to allocate memory for cmd->buf_ptr\n");
851 iscsit_free_cmd(cmd, false);
857 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
861 cmd->i_state = ISTATE_SEND_REJECT;
862 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
869 target_put_sess_cmd(&cmd->se_cmd);
874 static int iscsit_add_reject_cmd(struct iscsit_cmd *cmd, u8 reason,
877 return iscsit_add_reject_from_cmd(cmd, reason, true, buf);
880 int iscsit_reject_cmd(struct iscsit_cmd *cmd, u8 reason, unsigned char *buf)
882 return iscsit_add_reject_from_cmd(cmd, reason, false, buf);
890 static int iscsit_map_iovec(struct iscsit_cmd *cmd, struct kvec *iov, int nvec,
905 if (ent >= cmd->se_cmd.t_data_nents) {
910 sg = &cmd->se_cmd.t_data_sg[ent];
913 cmd->first_data_sg = sg;
914 cmd->first_data_sg_off = page_off;
933 cmd->kmapped_nents = i;
940 for_each_sg(cmd->se_cmd.t_data_sg, sg,
941 cmd->se_cmd.t_data_nents, i) {
948 static void iscsit_unmap_iovec(struct iscsit_cmd *cmd)
953 sg = cmd->first_data_sg;
955 for (i = 0; i < cmd->kmapped_nents; i++)
962 struct iscsit_cmd *cmd, *cmd_p;
970 list_for_each_entry_safe(cmd, cmd_p, &conn->conn_cmd_list, i_conn_node) {
971 spin_lock(&cmd->istate_lock);
972 if ((cmd->i_state == ISTATE_SENT_STATUS) &&
973 iscsi_sna_lt(cmd->stat_sn, exp_statsn)) {
974 cmd->i_state = ISTATE_REMOVE;
975 spin_unlock(&cmd->istate_lock);
976 list_move_tail(&cmd->i_conn_node, &ack_list);
979 spin_unlock(&cmd->istate_lock);
983 list_for_each_entry_safe(cmd, cmd_p, &ack_list, i_conn_node) {
984 list_del_init(&cmd->i_conn_node);
985 iscsit_free_cmd(cmd, false);
989 static int iscsit_allocate_iovecs(struct iscsit_cmd *cmd)
991 u32 iov_count = max(1UL, DIV_ROUND_UP(cmd->se_cmd.data_length, PAGE_SIZE));
994 cmd->iov_data = kcalloc(iov_count, sizeof(*cmd->iov_data), GFP_KERNEL);
995 if (!cmd->iov_data)
998 cmd->orig_iov_data_count = iov_count;
1002 int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1023 return iscsit_add_reject_cmd(cmd,
1052 return iscsit_add_reject_cmd(cmd,
1059 return iscsit_add_reject_cmd(cmd,
1066 return iscsit_add_reject_cmd(cmd,
1073 return iscsit_add_reject_cmd(cmd,
1082 return iscsit_add_reject_cmd(cmd,
1090 return iscsit_add_reject_cmd(cmd,
1098 return iscsit_add_reject_cmd(cmd,
1106 return iscsit_add_reject_cmd(cmd,
1117 return iscsit_add_reject_cmd(cmd,
1124 return iscsit_add_reject_cmd(cmd,
1135 cmd->data_direction = data_direction;
1155 cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD;
1156 cmd->i_state = ISTATE_NEW_CMD;
1157 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
1158 cmd->immediate_data = (payload_length) ? 1 : 0;
1159 cmd->unsolicited_data = ((!(hdr->flags & ISCSI_FLAG_CMD_FINAL) &&
1161 if (cmd->unsolicited_data)
1162 cmd->cmd_flags |= ICF_NON_IMMEDIATE_UNSOLICITED_DATA;
1164 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
1166 cmd->targ_xfer_tag = session_get_next_ttt(conn->sess);
1168 cmd->targ_xfer_tag = 0xFFFFFFFF;
1169 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1170 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1171 cmd->first_burst_len = payload_length;
1174 cmd->data_direction == DMA_FROM_DEVICE) {
1181 return iscsit_add_reject_cmd(cmd,
1185 iscsit_attach_datain_req(cmd, dr);
1191 __target_init_cmd(&cmd->se_cmd, &iscsi_ops,
1193 cmd->data_direction, sam_task_attr,
1194 cmd->sense_buffer + 2, scsilun_to_int(&hdr->lun),
1202 target_get_sess_cmd(&cmd->se_cmd, true);
1204 cmd->se_cmd.tag = (__force u32)cmd->init_task_tag;
1205 cmd->sense_reason = target_cmd_init_cdb(&cmd->se_cmd, cdb,
1211 if (cmd->sense_reason) {
1212 if (cmd->sense_reason == TCM_OUT_OF_RESOURCES) {
1213 return iscsit_add_reject_cmd(cmd,
1220 cmd->sense_reason = transport_lookup_cmd_lun(&cmd->se_cmd);
1221 if (cmd->sense_reason)
1224 cmd->sense_reason = target_cmd_parse_cdb(&cmd->se_cmd);
1225 if (cmd->sense_reason)
1228 if (iscsit_build_pdu_and_seq_lists(cmd, payload_length) < 0) {
1229 return iscsit_add_reject_cmd(cmd,
1235 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1241 core_alua_check_nonop_delay(&cmd->se_cmd);
1247 void iscsit_set_unsolicited_dataout(struct iscsit_cmd *cmd)
1249 iscsit_set_dataout_sequence_values(cmd);
1251 spin_lock_bh(&cmd->dataout_timeout_lock);
1252 iscsit_start_dataout_timer(cmd, cmd->conn);
1253 spin_unlock_bh(&cmd->dataout_timeout_lock);
1257 int iscsit_process_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1271 if (!cmd->immediate_data) {
1272 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1277 target_put_sess_cmd(&cmd->se_cmd);
1287 if (!cmd->immediate_data) {
1288 if (!cmd->sense_reason && cmd->unsolicited_data)
1289 iscsit_set_unsolicited_dataout(cmd);
1290 if (!cmd->sense_reason)
1293 target_put_sess_cmd(&cmd->se_cmd);
1302 if (cmd->sense_reason)
1308 cmd->sense_reason = transport_generic_new_cmd(&cmd->se_cmd);
1309 if (cmd->sense_reason)
1317 iscsit_get_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
1327 u32 length = min(cmd->se_cmd.data_length - cmd->write_data_done,
1328 cmd->first_burst_len);
1331 cmd->se_cmd.data_length, cmd->write_data_done,
1332 cmd->first_burst_len, length);
1333 rc = iscsit_dump_data_payload(cmd->conn, length, 1);
1338 immed_ret = iscsit_handle_immediate_data(cmd, hdr,
1339 cmd->first_burst_len);
1348 cmdsn_ret = iscsit_sequence_cmd(cmd->conn, cmd,
1353 if (cmd->sense_reason || cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
1354 target_put_sess_cmd(&cmd->se_cmd);
1357 } else if (cmd->unsolicited_data)
1358 iscsit_set_unsolicited_dataout(cmd);
1372 cmd->i_state = ISTATE_REMOVE;
1373 iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, cmd->i_state);
1381 iscsit_handle_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1388 rc = iscsit_setup_scsi_cmd(conn, cmd, buf);
1395 if (iscsit_allocate_iovecs(cmd) < 0) {
1396 return iscsit_reject_cmd(cmd,
1399 immed_data = cmd->immediate_data;
1401 rc = iscsit_process_scsi_cmd(conn, cmd, hdr);
1410 return iscsit_get_immediate_data(cmd, hdr, dump_payload);
1415 struct iscsit_cmd *cmd,
1427 sg = cmd->first_data_sg;
1428 page_off = cmd->first_data_sg_off;
1488 struct iscsit_cmd *cmd, u32 payload_length,
1503 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
1506 cmd->init_task_tag);
1510 if (cmd->data_direction != DMA_TO_DEVICE) {
1512 " NON-WRITE command.\n", cmd->init_task_tag);
1515 se_cmd = &cmd->se_cmd;
1516 iscsit_mod_dataout_timer(cmd);
1518 if ((be32_to_cpu(hdr->offset) + payload_length) > cmd->se_cmd.data_length) {
1521 cmd->se_cmd.data_length);
1522 return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_INVALID, buf);
1525 if (cmd->unsolicited_data) {
1531 transport_send_check_condition_and_sense(&cmd->se_cmd,
1553 iscsit_stop_dataout_timer(cmd);
1570 --cmd->outstanding_r2ts < 1)
1571 iscsit_stop_dataout_timer(cmd);
1580 rc = iscsit_check_pre_dataout(cmd, buf);
1595 struct iscsit_cmd *cmd;
1612 cmd = iscsit_find_cmd_from_itt_or_dump(conn, hdr->itt, payload_length);
1613 if (!cmd)
1616 rc = __iscsit_check_dataout_hdr(conn, buf, cmd, payload_length, &success);
1619 *out_cmd = cmd;
1626 iscsit_get_dataout(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1634 payload_length = min_t(u32, cmd->se_cmd.data_length,
1637 iov = &cmd->iov_data[0];
1639 iov_ret = iscsit_map_iovec(cmd, iov, cmd->orig_iov_data_count - 2,
1648 iov[iov_count].iov_base = cmd->pad_bytes;
1660 WARN_ON_ONCE(iov_count > cmd->orig_iov_data_count);
1661 rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);
1663 iscsit_unmap_iovec(cmd);
1671 data_crc = iscsit_do_crypto_hash_sg(conn->conn_rx_hash, cmd,
1674 cmd->pad_bytes);
1694 iscsit_check_dataout_payload(struct iscsit_cmd *cmd, struct iscsi_data *hdr,
1697 struct iscsit_conn *conn = cmd->conn;
1703 rc = iscsit_check_post_dataout(cmd, (unsigned char *)hdr, data_crc_failed);
1707 iscsit_set_dataout_sequence_values(cmd);
1708 conn->conn_transport->iscsit_get_dataout(conn, cmd, false);
1714 spin_lock_bh(&cmd->istate_lock);
1715 ooo_cmdsn = (cmd->cmd_flags & ICF_OOO_CMDSN);
1716 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
1717 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
1718 spin_unlock_bh(&cmd->istate_lock);
1720 iscsit_stop_dataout_timer(cmd);
1723 target_execute_cmd(&cmd->se_cmd);
1734 struct iscsit_cmd *cmd = NULL;
1739 rc = iscsit_check_dataout_hdr(conn, buf, &cmd);
1742 else if (!cmd)
1745 rc = iscsit_get_dataout(conn, cmd, hdr);
1751 return iscsit_check_dataout_payload(cmd, hdr, data_crc_failed);
1754 int iscsit_setup_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1761 if (!cmd)
1765 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1772 if (!cmd)
1776 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1785 if (!cmd)
1789 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1806 cmd->iscsi_opcode = ISCSI_OP_NOOP_OUT;
1807 cmd->i_state = ISTATE_SEND_NOPIN;
1808 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ?
1810 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
1811 cmd->targ_xfer_tag = 0xFFFFFFFF;
1812 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1813 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1814 cmd->data_direction = DMA_NONE;
1821 int iscsit_process_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1830 if (!cmd)
1835 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1841 iscsit_add_cmd_to_response_queue(cmd, conn,
1842 cmd->i_state);
1846 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1876 if (cmd)
1877 iscsit_free_cmd(cmd, false);
1883 static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
1892 ret = iscsit_setup_nop_out(conn, cmd, hdr);
1908 iov = &cmd->iov_misc[0];
1916 iov[niov].iov_base = &cmd->pad_bytes;
1926 WARN_ON_ONCE(niov > ARRAY_SIZE(cmd->iov_misc));
1927 rx_got = rx_data(conn, &cmd->iov_misc[0], niov, rx_size);
1936 cmd->pad_bytes, &data_crc);
1970 cmd->buf_ptr = ping_data;
1971 cmd->buf_ptr_size = payload_length;
1978 return iscsit_process_nop_out(conn, cmd, hdr);
1980 if (cmd)
1981 iscsit_free_cmd(cmd, false);
2010 iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
2040 return iscsit_add_reject_cmd(cmd,
2047 cmd->data_direction = DMA_NONE;
2048 cmd->tmr_req = kzalloc(sizeof(*cmd->tmr_req), GFP_KERNEL);
2049 if (!cmd->tmr_req) {
2050 return iscsit_add_reject_cmd(cmd,
2055 __target_init_cmd(&cmd->se_cmd, &iscsi_ops,
2057 TCM_SIMPLE_TAG, cmd->sense_buffer + 2,
2061 target_get_sess_cmd(&cmd->se_cmd, true);
2072 return iscsit_add_reject_cmd(cmd,
2076 ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req, tcm_function,
2079 return iscsit_add_reject_cmd(cmd,
2082 cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req;
2084 cmd->iscsi_opcode = ISCSI_OP_SCSI_TMFUNC;
2085 cmd->i_state = ISTATE_SEND_TASKMGTRSP;
2086 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
2087 cmd->init_task_tag = hdr->itt;
2088 cmd->targ_xfer_tag = 0xFFFFFFFF;
2089 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
2090 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
2091 se_tmr = cmd->se_cmd.se_tmr_req;
2092 tmr_req = cmd->tmr_req;
2097 ret = transport_lookup_tmr_lun(&cmd->se_cmd);
2106 se_tmr->response = iscsit_tmr_abort_task(cmd, buf);
2128 se_tmr->response = iscsit_tmr_task_reassign(cmd, buf);
2137 return iscsit_add_reject_cmd(cmd,
2152 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2156 int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
2160 target_put_sess_cmd(&cmd->se_cmd);
2174 return transport_generic_handle_tmr(&cmd->se_cmd);
2184 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2185 target_put_sess_cmd(&cmd->se_cmd);
2192 iscsit_setup_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
2201 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
2208 return iscsit_reject_cmd(cmd, ISCSI_REASON_CMD_NOT_SUPPORTED,
2216 cmd->iscsi_opcode = ISCSI_OP_TEXT;
2217 cmd->i_state = ISTATE_SEND_TEXTRSP;
2218 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
2219 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
2220 cmd->targ_xfer_tag = 0xFFFFFFFF;
2221 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
2222 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
2223 cmd->data_direction = DMA_NONE;
2224 kfree(cmd->text_in_ptr);
2225 cmd->text_in_ptr = NULL;
2232 iscsit_process_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
2235 unsigned char *text_in = cmd->text_in_ptr, *text_ptr;
2239 cmd->targ_xfer_tag = be32_to_cpu(hdr->ttt);
2240 if (cmd->targ_xfer_tag == 0xFFFFFFFF) {
2256 cmd->cmd_flags |= ICF_SENDTARGETS_ALL;
2259 cmd->cmd_flags |= ICF_SENDTARGETS_SINGLE;
2267 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2274 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
2282 return iscsit_execute_cmd(cmd, 0);
2285 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
2291 iscsit_handle_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
2299 rc = iscsit_setup_text_cmd(conn, cmd, hdr);
2315 cmd->text_in_ptr = text_in;
2372 return iscsit_process_text_cmd(conn, cmd, hdr);
2375 kfree(cmd->text_in_ptr);
2376 cmd->text_in_ptr = NULL;
2377 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
2380 int iscsit_logout_closesession(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
2405 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2410 int iscsit_logout_closeconnection(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
2416 " %hu on CID: %hu.\n", cmd->logout_cid, conn->cid);
2422 if (conn->cid == cmd->logout_cid) {
2442 cmd->logout_cid);
2444 cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND;
2445 iscsit_add_cmd_to_response_queue(cmd, conn,
2446 cmd->i_state);
2453 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2458 int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
2463 " CID: %hu on CID: %hu.\n", cmd->logout_cid, conn->cid);
2468 cmd->logout_response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED;
2469 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2473 if (conn->cid == cmd->logout_cid) {
2476 cmd->logout_cid, conn->cid);
2477 cmd->logout_response = ISCSI_LOGOUT_CLEANUP_FAILED;
2478 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2482 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
2488 iscsit_handle_logout_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
2516 iscsit_free_cmd(cmd, false);
2520 cmd->iscsi_opcode = ISCSI_OP_LOGOUT;
2521 cmd->i_state = ISTATE_SEND_LOGOUTRSP;
2522 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
2523 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
2524 cmd->targ_xfer_tag = 0xFFFFFFFF;
2525 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
2526 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
2527 cmd->logout_cid = be16_to_cpu(hdr->cid);
2528 cmd->logout_reason = reason_code;
2529 cmd->data_direction = DMA_NONE;
2541 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2551 if (cmd->immediate_cmd) {
2552 int ret = iscsit_execute_cmd(cmd, 0);
2557 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
2634 struct iscsit_cmd *cmd,
2640 struct iscsit_conn *conn = cmd->conn;
2644 BUG_ON(cmd->write_data_done > cmd->se_cmd.data_length);
2645 rx_size = min(cmd->se_cmd.data_length - cmd->write_data_done, length);
2646 iov_ret = iscsit_map_iovec(cmd, cmd->iov_data,
2647 cmd->orig_iov_data_count - 2,
2648 cmd->write_data_done, rx_size);
2653 iov = &cmd->iov_data[0];
2661 iscsit_unmap_iovec(cmd);
2664 cmd->overflow_buf = overflow_buf;
2673 iov[iov_count].iov_base = cmd->pad_bytes;
2684 WARN_ON_ONCE(iov_count > cmd->orig_iov_data_count);
2685 rx_got = rx_data(conn, &cmd->iov_data[0], iov_count, rx_size);
2687 iscsit_unmap_iovec(cmd);
2697 data_crc = iscsit_do_crypto_hash_sg(conn->conn_rx_hash, cmd,
2698 cmd->write_data_done, length, padding,
2699 cmd->pad_bytes);
2710 iscsit_reject_cmd(cmd,
2715 iscsit_reject_cmd(cmd,
2727 cmd->write_data_done += length;
2729 if (cmd->write_data_done == cmd->se_cmd.data_length) {
2730 spin_lock_bh(&cmd->istate_lock);
2731 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
2732 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
2733 spin_unlock_bh(&cmd->istate_lock);
2743 struct iscsit_cmd *cmd;
2764 cmd = iscsit_allocate_cmd(conn_p, TASK_RUNNING);
2765 if (!cmd) {
2770 cmd->logout_cid = conn->cid;
2771 cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT;
2772 cmd->i_state = ISTATE_SEND_ASYNCMSG;
2775 list_add_tail(&cmd->i_conn_node, &conn_p->conn_cmd_list);
2778 iscsit_add_cmd_to_response_queue(cmd, conn_p, cmd->i_state);
2783 struct iscsit_cmd *cmd,
2788 cmd->iscsi_opcode = ISCSI_OP_ASYNC_EVENT;
2790 hdr = (struct iscsi_async *) cmd->pdu;
2793 cmd->init_task_tag = RESERVED_ITT;
2794 cmd->targ_xfer_tag = 0xFFFFFFFF;
2796 cmd->stat_sn = conn->stat_sn++;
2797 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2801 hdr->param1 = cpu_to_be16(cmd->logout_cid);
2806 " 0x%08x, for CID: %hu on CID: %hu\n", cmd->stat_sn,
2807 cmd->logout_cid, conn->cid);
2809 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
2823 iscsit_build_datain_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
2830 if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {
2832 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
2833 } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {
2835 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
2840 int_to_scsilun(cmd->se_cmd.orig_fe_lun,
2845 hdr->itt = cmd->init_task_tag;
2848 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
2852 hdr->statsn = cpu_to_be32(cmd->stat_sn);
2863 cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn),
2868 static int iscsit_send_datain(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
2870 struct iscsi_data_rsp *hdr = (struct iscsi_data_rsp *)&cmd->pdu[0];
2877 dr = iscsit_get_datain_values(cmd, &datain);
2880 cmd->init_task_tag);
2886 if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {
2888 " datain.length: %u exceeds cmd->data_length: %u\n",
2889 cmd->init_task_tag, datain.offset, datain.length,
2890 cmd->se_cmd.data_length);
2900 (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE))
2905 iscsit_increment_maxcmdsn(cmd, conn->sess);
2906 cmd->stat_sn = conn->stat_sn++;
2913 iscsit_build_datain_pdu(cmd, conn, &datain, hdr, set_statsn);
2915 ret = conn->conn_transport->iscsit_xmit_pdu(conn, cmd, dr, &datain, 0);
2920 eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ?
2922 iscsit_free_datain_req(cmd, dr);
2929 iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
2940 switch (cmd->logout_reason) {
2944 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2947 if (cmd->logout_response == ISCSI_LOGOUT_CID_NOT_FOUND)
2957 * on, the connection responding to cmd->logout_cid
2962 " successful.\n", cmd->logout_cid, conn->cid);
2963 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2966 if ((cmd->logout_response == ISCSI_LOGOUT_RECOVERY_UNSUPPORTED) ||
2967 (cmd->logout_response == ISCSI_LOGOUT_CLEANUP_FAILED))
2974 cmd->logout_cid);
2981 conn->sess, cmd->logout_cid);
2985 cmd->logout_cid);
2986 cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND;
2990 iscsit_discard_cr_cmds_by_expstatsn(cr, cmd->exp_stat_sn);
2994 cmd->logout_cid, conn->cid);
2995 cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
2998 pr_err("Unknown cmd->logout_reason: 0x%02x\n",
2999 cmd->logout_reason);
3005 hdr->response = cmd->logout_response;
3006 hdr->itt = cmd->init_task_tag;
3007 cmd->stat_sn = conn->stat_sn++;
3008 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3010 iscsit_increment_maxcmdsn(cmd, conn->sess);
3016 cmd->init_task_tag, cmd->stat_sn, hdr->response,
3017 cmd->logout_cid, conn->cid);
3024 iscsit_send_logout(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
3028 rc = iscsit_build_logout_rsp(cmd, conn,
3029 (struct iscsi_logout_rsp *)&cmd->pdu[0]);
3033 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
3037 iscsit_build_nopin_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
3042 hton24(hdr->dlength, cmd->buf_ptr_size);
3045 hdr->itt = cmd->init_task_tag;
3046 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
3047 cmd->stat_sn = (nopout_response) ? conn->stat_sn++ :
3049 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3052 iscsit_increment_maxcmdsn(cmd, conn->sess);
3059 "Solicited" : "Unsolicited", cmd->init_task_tag,
3060 cmd->targ_xfer_tag, cmd->stat_sn, cmd->buf_ptr_size);
3068 struct iscsit_cmd *cmd,
3072 struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
3075 iscsit_build_nopin_rsp(cmd, conn, hdr, false);
3078 " 0x%08x CID: %hu\n", hdr->ttt, cmd->stat_sn, conn->cid);
3080 ret = conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
3084 spin_lock_bh(&cmd->istate_lock);
3085 cmd->i_state = want_response ?
3087 spin_unlock_bh(&cmd->istate_lock);
3093 iscsit_send_nopin(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
3095 struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
3097 iscsit_build_nopin_rsp(cmd, conn, hdr, true);
3103 pr_debug("Echoing back %u bytes of ping data.\n", cmd->buf_ptr_size);
3105 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL,
3106 cmd->buf_ptr,
3107 cmd->buf_ptr_size);
3111 struct iscsit_cmd *cmd,
3118 r2t = iscsit_get_r2t_from_list(cmd);
3122 hdr = (struct iscsi_r2t_rsp *) cmd->pdu;
3126 int_to_scsilun(cmd->se_cmd.orig_fe_lun,
3128 hdr->itt = cmd->init_task_tag;
3130 conn->conn_transport->iscsit_get_r2t_ttt(conn, cmd, r2t);
3143 (!r2t->recovery_r2t) ? "" : "Recovery ", cmd->init_task_tag,
3147 spin_lock_bh(&cmd->r2t_lock);
3149 spin_unlock_bh(&cmd->r2t_lock);
3151 ret = conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
3156 spin_lock_bh(&cmd->dataout_timeout_lock);
3157 iscsit_start_dataout_timer(cmd, conn);
3158 spin_unlock_bh(&cmd->dataout_timeout_lock);
3169 struct iscsit_cmd *cmd,
3175 spin_lock_bh(&cmd->r2t_lock);
3176 if (cmd->cmd_flags & ICF_SENT_LAST_R2T) {
3177 spin_unlock_bh(&cmd->r2t_lock);
3183 cmd->r2t_offset = max(cmd->r2t_offset, cmd->write_data_done);
3185 while (cmd->outstanding_r2ts < conn->sess->sess_ops->MaxOutstandingR2T) {
3187 offset = cmd->r2t_offset;
3192 cmd->next_burst_len;
3194 if (new_data_end > cmd->se_cmd.data_length)
3195 xfer_len = cmd->se_cmd.data_length - offset;
3199 cmd->next_burst_len;
3204 if (new_data_end > cmd->se_cmd.data_length)
3205 xfer_len = cmd->se_cmd.data_length - offset;
3211 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
3215 cmd->r2t_offset += xfer_len;
3217 if (cmd->r2t_offset == cmd->se_cmd.data_length)
3218 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
3222 seq = iscsit_get_seq_holder_for_r2t(cmd);
3224 spin_unlock_bh(&cmd->r2t_lock);
3231 if (cmd->seq_send_order == cmd->seq_count)
3232 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
3234 cmd->outstanding_r2ts++;
3237 if (iscsit_add_r2t_to_list(cmd, offset, xfer_len, 0, 0) < 0) {
3238 spin_unlock_bh(&cmd->r2t_lock);
3242 if (cmd->cmd_flags & ICF_SENT_LAST_R2T)
3245 spin_unlock_bh(&cmd->r2t_lock);
3251 void iscsit_build_rsp_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
3255 cmd->stat_sn = conn->stat_sn++;
3262 if (cmd->se_cmd.se_cmd_flags & SCF_OVERFLOW_BIT) {
3264 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
3265 } else if (cmd->se_cmd.se_cmd_flags & SCF_UNDERFLOW_BIT) {
3267 hdr->residual_count = cpu_to_be32(cmd->se_cmd.residual_count);
3269 hdr->response = cmd->iscsi_response;
3270 hdr->cmd_status = cmd->se_cmd.scsi_status;
3271 hdr->itt = cmd->init_task_tag;
3272 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3274 iscsit_increment_maxcmdsn(cmd, conn->sess);
3280 cmd->init_task_tag, cmd->stat_sn, cmd->se_cmd.scsi_status,
3281 cmd->se_cmd.scsi_status, conn->cid);
3285 static int iscsit_send_response(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
3287 struct iscsi_scsi_rsp *hdr = (struct iscsi_scsi_rsp *)&cmd->pdu[0];
3288 bool inc_stat_sn = (cmd->i_state == ISTATE_SEND_STATUS);
3292 iscsit_build_rsp_pdu(cmd, conn, inc_stat_sn, hdr);
3297 if (cmd->se_cmd.sense_buffer &&
3298 ((cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||
3299 (cmd->se_cmd.se_cmd_flags & SCF_EMULATED_TASK_SENSE))) {
3300 put_unaligned_be16(cmd->se_cmd.scsi_sense_length, cmd->sense_buffer);
3301 cmd->se_cmd.scsi_sense_length += sizeof (__be16);
3303 padding = -(cmd->se_cmd.scsi_sense_length) & 3;
3304 hton24(hdr->dlength, (u32)cmd->se_cmd.scsi_sense_length);
3305 data_buf = cmd->sense_buffer;
3306 data_buf_len = cmd->se_cmd.scsi_sense_length + padding;
3309 memset(cmd->sense_buffer +
3310 cmd->se_cmd.scsi_sense_length, 0, padding);
3317 cmd->se_cmd.scsi_sense_length);
3320 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, data_buf,
3342 iscsit_build_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
3345 struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
3350 hdr->itt = cmd->init_task_tag;
3351 cmd->stat_sn = conn->stat_sn++;
3352 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3354 iscsit_increment_maxcmdsn(cmd, conn->sess);
3360 cmd->init_task_tag, cmd->stat_sn, hdr->response, conn->cid);
3365 iscsit_send_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
3367 struct iscsi_tm_rsp *hdr = (struct iscsi_tm_rsp *)&cmd->pdu[0];
3369 iscsit_build_task_mgt_rsp(cmd, conn, hdr);
3371 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
3377 iscsit_build_sendtargets_response(struct iscsit_cmd *cmd,
3382 struct iscsit_conn *conn = cmd->conn;
3389 unsigned char *text_in = cmd->text_in_ptr, *text_ptr = NULL;
3403 if (cmd->cmd_flags & ICF_SENDTARGETS_SINGLE) {
3419 if ((cmd->cmd_flags & ICF_SENDTARGETS_SINGLE) &&
3437 cmd->conn->sess->sess_ops->InitiatorName))) {
3516 if (cmd->cmd_flags & ICF_SENDTARGETS_SINGLE)
3521 cmd->buf_ptr = payload;
3527 iscsit_build_text_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
3534 text_length = iscsit_build_sendtargets_response(cmd, network_transport,
3535 cmd->read_data_done,
3544 cmd->read_data_done += text_length;
3545 if (cmd->targ_xfer_tag == 0xFFFFFFFF)
3546 cmd->targ_xfer_tag = session_get_next_ttt(conn->sess);
3551 hdr->itt = cmd->init_task_tag;
3552 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
3553 cmd->stat_sn = conn->stat_sn++;
3554 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3556 iscsit_increment_maxcmdsn(cmd, conn->sess);
3562 cmd->maxcmdsn_inc = 0;
3567 " Length: %u, CID: %hu F: %d C: %d\n", cmd->init_task_tag,
3568 cmd->targ_xfer_tag, cmd->stat_sn, text_length, conn->cid,
3577 struct iscsit_cmd *cmd,
3580 struct iscsi_text_rsp *hdr = (struct iscsi_text_rsp *)cmd->pdu;
3583 text_length = iscsit_build_text_rsp(cmd, conn, hdr,
3588 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL,
3589 cmd->buf_ptr,
3594 iscsit_build_reject(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
3598 hdr->reason = cmd->reject_reason;
3602 cmd->stat_sn = conn->stat_sn++;
3603 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3611 struct iscsit_cmd *cmd,
3614 struct iscsi_reject *hdr = (struct iscsi_reject *)&cmd->pdu[0];
3616 iscsit_build_reject(cmd, conn, hdr);
3621 return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL,
3622 cmd->buf_ptr,
3726 iscsit_immediate_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
3732 ret = iscsit_send_r2t(cmd, conn);
3738 list_del_init(&cmd->i_conn_node);
3741 iscsit_free_cmd(cmd, false);
3745 ret = iscsit_send_unsolicited_nopin(cmd, conn, 1);
3750 ret = iscsit_send_unsolicited_nopin(cmd, conn, 0);
3757 cmd->iscsi_opcode, cmd->init_task_tag, state,
3774 struct iscsit_cmd *cmd;
3780 cmd = qr->cmd;
3784 ret = t->iscsit_immediate_queue(conn, cmd, state);
3793 iscsit_response_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
3800 ret = iscsit_send_datain(cmd, conn);
3808 spin_lock_bh(&cmd->istate_lock);
3809 cmd->i_state = ISTATE_SENT_STATUS;
3810 spin_unlock_bh(&cmd->istate_lock);
3819 spin_lock_bh(&cmd->istate_lock);
3820 cmd->i_state = ISTATE_SEND_STATUS;
3821 spin_unlock_bh(&cmd->istate_lock);
3829 ret = iscsit_send_response(cmd, conn);
3832 ret = iscsit_send_logout(cmd, conn);
3836 cmd, conn);
3839 ret = iscsit_send_nopin(cmd, conn);
3842 ret = iscsit_send_reject(cmd, conn);
3845 ret = iscsit_send_task_mgt_rsp(cmd, conn);
3848 ret = iscsit_tmr_post_handler(cmd, conn);
3853 ret = iscsit_send_text_rsp(cmd, conn);
3858 cmd->iscsi_opcode, cmd->init_task_tag,
3867 if (!iscsit_logout_post_handler(cmd, conn))
3877 spin_lock_bh(&cmd->istate_lock);
3878 cmd->i_state = ISTATE_SENT_STATUS;
3879 spin_unlock_bh(&cmd->istate_lock);
3884 cmd->iscsi_opcode, cmd->init_task_tag,
3885 cmd->i_state, conn->cid);
3903 struct iscsit_cmd *cmd;
3908 cmd = qr->cmd;
3912 ret = t->iscsit_response_queue(conn, cmd, state);
3981 struct iscsit_cmd *cmd;
3986 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
3987 if (!cmd)
3990 ret = iscsit_handle_scsi_cmd(conn, cmd, buf);
3996 cmd = NULL;
3998 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
3999 if (!cmd)
4002 ret = iscsit_handle_nop_out(conn, cmd, buf);
4005 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4006 if (!cmd)
4009 ret = iscsit_handle_task_mgt_cmd(conn, cmd, buf);
4013 cmd = iscsit_find_cmd_from_itt(conn, hdr->itt);
4014 if (!cmd)
4017 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4018 if (!cmd)
4022 ret = iscsit_handle_text_cmd(conn, cmd, buf);
4025 cmd = iscsit_allocate_cmd(conn, TASK_INTERRUPTIBLE);
4026 if (!cmd)
4029 ret = iscsit_handle_logout_cmd(conn, cmd, buf);
4209 struct iscsit_cmd *cmd = NULL, *cmd_tmp = NULL;
4219 list_for_each_entry_safe(cmd, cmd_tmp, &tmp_list, i_conn_node) {
4220 struct se_cmd *se_cmd = &cmd->se_cmd;
4233 list_move_tail(&cmd->i_conn_node,
4239 if (cmd->se_cmd.t_state == TRANSPORT_WRITE_PENDING) {
4241 * We never submitted the cmd to LIO core, so we have
4245 target_complete_cmd(&cmd->se_cmd, SAM_STAT_TASK_ABORTED);
4252 list_for_each_entry_safe(cmd, cmd_tmp, &tmp_list, i_conn_node) {
4253 list_del_init(&cmd->i_conn_node);
4255 iscsit_increment_maxcmdsn(cmd, sess);
4256 iscsit_free_cmd(cmd, true);
4274 struct iscsit_cmd *cmd;
4277 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
4278 if (cmd->data_direction == DMA_TO_DEVICE)
4279 iscsit_stop_dataout_timer(cmd);
4679 struct iscsit_cmd *cmd,
4684 switch (cmd->logout_reason) {
4686 switch (cmd->logout_response) {
4695 if (conn->cid == cmd->logout_cid) {
4696 switch (cmd->logout_response) {
4704 switch (cmd->logout_response) {
4707 cmd->logout_cid);
4718 switch (cmd->logout_response) {