iscsi_target_erl2.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*******************************************************************************
  3. * This file contains error recovery level two functions used by
  4. * the iSCSI Target driver.
  5. *
  6. * (c) Copyright 2007-2013 Datera, Inc.
  7. *
  8. * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
  9. *
  10. ******************************************************************************/
  11. #include <linux/slab.h>
  12. #include <scsi/iscsi_proto.h>
  13. #include <target/target_core_base.h>
  14. #include <target/target_core_fabric.h>
  15. #include <target/iscsi/iscsi_target_core.h>
  16. #include "iscsi_target_datain_values.h"
  17. #include "iscsi_target_util.h"
  18. #include "iscsi_target_erl0.h"
  19. #include "iscsi_target_erl1.h"
  20. #include "iscsi_target_erl2.h"
  21. #include "iscsi_target.h"
  22. /*
  23. * FIXME: Does RData SNACK apply here as well?
  24. */
  25. void iscsit_create_conn_recovery_datain_values(
  26. struct iscsi_cmd *cmd,
  27. __be32 exp_data_sn)
  28. {
  29. u32 data_sn = 0;
  30. struct iscsi_conn *conn = cmd->conn;
  31. cmd->next_burst_len = 0;
  32. cmd->read_data_done = 0;
  33. while (be32_to_cpu(exp_data_sn) > data_sn) {
  34. if ((cmd->next_burst_len +
  35. conn->conn_ops->MaxRecvDataSegmentLength) <
  36. conn->sess->sess_ops->MaxBurstLength) {
  37. cmd->read_data_done +=
  38. conn->conn_ops->MaxRecvDataSegmentLength;
  39. cmd->next_burst_len +=
  40. conn->conn_ops->MaxRecvDataSegmentLength;
  41. } else {
  42. cmd->read_data_done +=
  43. (conn->sess->sess_ops->MaxBurstLength -
  44. cmd->next_burst_len);
  45. cmd->next_burst_len = 0;
  46. }
  47. data_sn++;
  48. }
  49. }
  50. void iscsit_create_conn_recovery_dataout_values(
  51. struct iscsi_cmd *cmd)
  52. {
  53. u32 write_data_done = 0;
  54. struct iscsi_conn *conn = cmd->conn;
  55. cmd->data_sn = 0;
  56. cmd->next_burst_len = 0;
  57. while (cmd->write_data_done > write_data_done) {
  58. if ((write_data_done + conn->sess->sess_ops->MaxBurstLength) <=
  59. cmd->write_data_done)
  60. write_data_done += conn->sess->sess_ops->MaxBurstLength;
  61. else
  62. break;
  63. }
  64. cmd->write_data_done = write_data_done;
  65. }
  66. static int iscsit_attach_active_connection_recovery_entry(
  67. struct iscsi_session *sess,
  68. struct iscsi_conn_recovery *cr)
  69. {
  70. spin_lock(&sess->cr_a_lock);
  71. list_add_tail(&cr->cr_list, &sess->cr_active_list);
  72. spin_unlock(&sess->cr_a_lock);
  73. return 0;
  74. }
  75. static int iscsit_attach_inactive_connection_recovery_entry(
  76. struct iscsi_session *sess,
  77. struct iscsi_conn_recovery *cr)
  78. {
  79. spin_lock(&sess->cr_i_lock);
  80. list_add_tail(&cr->cr_list, &sess->cr_inactive_list);
  81. sess->conn_recovery_count++;
  82. pr_debug("Incremented connection recovery count to %u for"
  83. " SID: %u\n", sess->conn_recovery_count, sess->sid);
  84. spin_unlock(&sess->cr_i_lock);
  85. return 0;
  86. }
  87. struct iscsi_conn_recovery *iscsit_get_inactive_connection_recovery_entry(
  88. struct iscsi_session *sess,
  89. u16 cid)
  90. {
  91. struct iscsi_conn_recovery *cr;
  92. spin_lock(&sess->cr_i_lock);
  93. list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
  94. if (cr->cid == cid) {
  95. spin_unlock(&sess->cr_i_lock);
  96. return cr;
  97. }
  98. }
  99. spin_unlock(&sess->cr_i_lock);
  100. return NULL;
  101. }
  102. void iscsit_free_connection_recovery_entries(struct iscsi_session *sess)
  103. {
  104. struct iscsi_cmd *cmd, *cmd_tmp;
  105. struct iscsi_conn_recovery *cr, *cr_tmp;
  106. spin_lock(&sess->cr_a_lock);
  107. list_for_each_entry_safe(cr, cr_tmp, &sess->cr_active_list, cr_list) {
  108. list_del(&cr->cr_list);
  109. spin_unlock(&sess->cr_a_lock);
  110. spin_lock(&cr->conn_recovery_cmd_lock);
  111. list_for_each_entry_safe(cmd, cmd_tmp,
  112. &cr->conn_recovery_cmd_list, i_conn_node) {
  113. list_del_init(&cmd->i_conn_node);
  114. cmd->conn = NULL;
  115. spin_unlock(&cr->conn_recovery_cmd_lock);
  116. iscsit_free_cmd(cmd, true);
  117. spin_lock(&cr->conn_recovery_cmd_lock);
  118. }
  119. spin_unlock(&cr->conn_recovery_cmd_lock);
  120. spin_lock(&sess->cr_a_lock);
  121. kfree(cr);
  122. }
  123. spin_unlock(&sess->cr_a_lock);
  124. spin_lock(&sess->cr_i_lock);
  125. list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
  126. list_del(&cr->cr_list);
  127. spin_unlock(&sess->cr_i_lock);
  128. spin_lock(&cr->conn_recovery_cmd_lock);
  129. list_for_each_entry_safe(cmd, cmd_tmp,
  130. &cr->conn_recovery_cmd_list, i_conn_node) {
  131. list_del_init(&cmd->i_conn_node);
  132. cmd->conn = NULL;
  133. spin_unlock(&cr->conn_recovery_cmd_lock);
  134. iscsit_free_cmd(cmd, true);
  135. spin_lock(&cr->conn_recovery_cmd_lock);
  136. }
  137. spin_unlock(&cr->conn_recovery_cmd_lock);
  138. spin_lock(&sess->cr_i_lock);
  139. kfree(cr);
  140. }
  141. spin_unlock(&sess->cr_i_lock);
  142. }
  143. int iscsit_remove_active_connection_recovery_entry(
  144. struct iscsi_conn_recovery *cr,
  145. struct iscsi_session *sess)
  146. {
  147. spin_lock(&sess->cr_a_lock);
  148. list_del(&cr->cr_list);
  149. sess->conn_recovery_count--;
  150. pr_debug("Decremented connection recovery count to %u for"
  151. " SID: %u\n", sess->conn_recovery_count, sess->sid);
  152. spin_unlock(&sess->cr_a_lock);
  153. kfree(cr);
  154. return 0;
  155. }
  156. static void iscsit_remove_inactive_connection_recovery_entry(
  157. struct iscsi_conn_recovery *cr,
  158. struct iscsi_session *sess)
  159. {
  160. spin_lock(&sess->cr_i_lock);
  161. list_del(&cr->cr_list);
  162. spin_unlock(&sess->cr_i_lock);
  163. }
  164. /*
  165. * Called with cr->conn_recovery_cmd_lock help.
  166. */
  167. int iscsit_remove_cmd_from_connection_recovery(
  168. struct iscsi_cmd *cmd,
  169. struct iscsi_session *sess)
  170. {
  171. struct iscsi_conn_recovery *cr;
  172. if (!cmd->cr) {
  173. pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
  174. " is NULL!\n", cmd->init_task_tag);
  175. BUG();
  176. }
  177. cr = cmd->cr;
  178. list_del_init(&cmd->i_conn_node);
  179. return --cr->cmd_count;
  180. }
  181. void iscsit_discard_cr_cmds_by_expstatsn(
  182. struct iscsi_conn_recovery *cr,
  183. u32 exp_statsn)
  184. {
  185. u32 dropped_count = 0;
  186. struct iscsi_cmd *cmd, *cmd_tmp;
  187. struct iscsi_session *sess = cr->sess;
  188. spin_lock(&cr->conn_recovery_cmd_lock);
  189. list_for_each_entry_safe(cmd, cmd_tmp,
  190. &cr->conn_recovery_cmd_list, i_conn_node) {
  191. if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
  192. (cmd->deferred_i_state != ISTATE_REMOVE)) ||
  193. (cmd->stat_sn >= exp_statsn)) {
  194. continue;
  195. }
  196. dropped_count++;
  197. pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
  198. " 0x%08x, CID: %hu.\n", cmd->init_task_tag,
  199. cmd->stat_sn, cr->cid);
  200. iscsit_remove_cmd_from_connection_recovery(cmd, sess);
  201. spin_unlock(&cr->conn_recovery_cmd_lock);
  202. iscsit_free_cmd(cmd, true);
  203. spin_lock(&cr->conn_recovery_cmd_lock);
  204. }
  205. spin_unlock(&cr->conn_recovery_cmd_lock);
  206. pr_debug("Dropped %u total acknowledged commands on"
  207. " CID: %hu less than old ExpStatSN: 0x%08x\n",
  208. dropped_count, cr->cid, exp_statsn);
  209. if (!cr->cmd_count) {
  210. pr_debug("No commands to be reassigned for failed"
  211. " connection CID: %hu on SID: %u\n",
  212. cr->cid, sess->sid);
  213. iscsit_remove_inactive_connection_recovery_entry(cr, sess);
  214. iscsit_attach_active_connection_recovery_entry(sess, cr);
  215. pr_debug("iSCSI connection recovery successful for CID:"
  216. " %hu on SID: %u\n", cr->cid, sess->sid);
  217. iscsit_remove_active_connection_recovery_entry(cr, sess);
  218. } else {
  219. iscsit_remove_inactive_connection_recovery_entry(cr, sess);
  220. iscsit_attach_active_connection_recovery_entry(sess, cr);
  221. }
  222. }
  223. int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
  224. {
  225. u32 dropped_count = 0;
  226. struct iscsi_cmd *cmd, *cmd_tmp;
  227. struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp;
  228. struct iscsi_session *sess = conn->sess;
  229. mutex_lock(&sess->cmdsn_mutex);
  230. list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
  231. &sess->sess_ooo_cmdsn_list, ooo_list) {
  232. if (ooo_cmdsn->cid != conn->cid)
  233. continue;
  234. dropped_count++;
  235. pr_debug("Dropping unacknowledged CmdSN:"
  236. " 0x%08x during connection recovery on CID: %hu\n",
  237. ooo_cmdsn->cmdsn, conn->cid);
  238. iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
  239. }
  240. mutex_unlock(&sess->cmdsn_mutex);
  241. spin_lock_bh(&conn->cmd_lock);
  242. list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
  243. if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
  244. continue;
  245. list_del_init(&cmd->i_conn_node);
  246. spin_unlock_bh(&conn->cmd_lock);
  247. iscsit_free_cmd(cmd, true);
  248. spin_lock_bh(&conn->cmd_lock);
  249. }
  250. spin_unlock_bh(&conn->cmd_lock);
  251. pr_debug("Dropped %u total unacknowledged commands on CID:"
  252. " %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
  253. sess->exp_cmd_sn);
  254. return 0;
  255. }
  256. int iscsit_prepare_cmds_for_reallegiance(struct iscsi_conn *conn)
  257. {
  258. u32 cmd_count = 0;
  259. struct iscsi_cmd *cmd, *cmd_tmp;
  260. struct iscsi_conn_recovery *cr;
  261. /*
  262. * Allocate an struct iscsi_conn_recovery for this connection.
  263. * Each struct iscsi_cmd contains an struct iscsi_conn_recovery pointer
  264. * (struct iscsi_cmd->cr) so we need to allocate this before preparing the
  265. * connection's command list for connection recovery.
  266. */
  267. cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
  268. if (!cr) {
  269. pr_err("Unable to allocate memory for"
  270. " struct iscsi_conn_recovery.\n");
  271. return -1;
  272. }
  273. INIT_LIST_HEAD(&cr->cr_list);
  274. INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
  275. spin_lock_init(&cr->conn_recovery_cmd_lock);
  276. /*
  277. * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
  278. * ISCSI_OP_NOOP_OUT opcodes. For all other opcodes call
  279. * list_del_init(&cmd->i_conn_node); to release the command to the
  280. * session pool and remove it from the connection's list.
  281. *
  282. * Also stop the DataOUT timer, which will be restarted after
  283. * sending the TMR response.
  284. */
  285. spin_lock_bh(&conn->cmd_lock);
  286. list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
  287. if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
  288. (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
  289. pr_debug("Not performing reallegiance on"
  290. " Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
  291. " CID: %hu\n", cmd->iscsi_opcode,
  292. cmd->init_task_tag, cmd->cmd_sn, conn->cid);
  293. list_del_init(&cmd->i_conn_node);
  294. spin_unlock_bh(&conn->cmd_lock);
  295. iscsit_free_cmd(cmd, true);
  296. spin_lock_bh(&conn->cmd_lock);
  297. continue;
  298. }
  299. /*
  300. * Special case where commands greater than or equal to
  301. * the session's ExpCmdSN are attached to the connection
  302. * list but not to the out of order CmdSN list. The one
  303. * obvious case is when a command with immediate data
  304. * attached must only check the CmdSN against ExpCmdSN
  305. * after the data is received. The special case below
  306. * is when the connection fails before data is received,
  307. * but also may apply to other PDUs, so it has been
  308. * made generic here.
  309. */
  310. if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
  311. iscsi_sna_gte(cmd->cmd_sn, conn->sess->exp_cmd_sn)) {
  312. list_del_init(&cmd->i_conn_node);
  313. spin_unlock_bh(&conn->cmd_lock);
  314. iscsit_free_cmd(cmd, true);
  315. spin_lock_bh(&conn->cmd_lock);
  316. continue;
  317. }
  318. cmd_count++;
  319. pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
  320. " CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
  321. " reallegiance.\n", cmd->iscsi_opcode,
  322. cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
  323. conn->cid);
  324. cmd->deferred_i_state = cmd->i_state;
  325. cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;
  326. if (cmd->data_direction == DMA_TO_DEVICE)
  327. iscsit_stop_dataout_timer(cmd);
  328. cmd->sess = conn->sess;
  329. list_del_init(&cmd->i_conn_node);
  330. spin_unlock_bh(&conn->cmd_lock);
  331. iscsit_free_all_datain_reqs(cmd);
  332. transport_wait_for_tasks(&cmd->se_cmd);
  333. /*
  334. * Add the struct iscsi_cmd to the connection recovery cmd list
  335. */
  336. spin_lock(&cr->conn_recovery_cmd_lock);
  337. list_add_tail(&cmd->i_conn_node, &cr->conn_recovery_cmd_list);
  338. spin_unlock(&cr->conn_recovery_cmd_lock);
  339. spin_lock_bh(&conn->cmd_lock);
  340. cmd->cr = cr;
  341. cmd->conn = NULL;
  342. }
  343. spin_unlock_bh(&conn->cmd_lock);
  344. /*
  345. * Fill in the various values in the preallocated struct iscsi_conn_recovery.
  346. */
  347. cr->cid = conn->cid;
  348. cr->cmd_count = cmd_count;
  349. cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
  350. cr->maxxmitdatasegmentlength = conn->conn_ops->MaxXmitDataSegmentLength;
  351. cr->sess = conn->sess;
  352. iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);
  353. return 0;
  354. }
  355. int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
  356. {
  357. atomic_set(&conn->connection_recovery, 1);
  358. if (iscsit_close_connection(conn) < 0)
  359. return -1;
  360. return 0;
  361. }