iscsi_target_erl0.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /******************************************************************************
  3. * This file contains error recovery level zero 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/sched/signal.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_seq_pdu_list.h"
  17. #include "iscsi_target_erl0.h"
  18. #include "iscsi_target_erl1.h"
  19. #include "iscsi_target_erl2.h"
  20. #include "iscsi_target_util.h"
  21. #include "iscsi_target.h"
  22. /*
  23. * Used to set values in struct iscsi_cmd that iscsit_dataout_check_sequence()
  24. * checks against to determine a PDU's Offset+Length is within the current
  25. * DataOUT Sequence. Used for DataSequenceInOrder=Yes only.
  26. */
  27. void iscsit_set_dataout_sequence_values(
  28. struct iscsi_cmd *cmd)
  29. {
  30. struct iscsi_conn *conn = cmd->conn;
  31. /*
  32. * Still set seq_start_offset and seq_end_offset for Unsolicited
  33. * DataOUT, even if DataSequenceInOrder=No.
  34. */
  35. if (cmd->unsolicited_data) {
  36. cmd->seq_start_offset = cmd->write_data_done;
  37. cmd->seq_end_offset = min(cmd->se_cmd.data_length,
  38. conn->sess->sess_ops->FirstBurstLength);
  39. return;
  40. }
  41. if (!conn->sess->sess_ops->DataSequenceInOrder)
  42. return;
  43. if (!cmd->seq_start_offset && !cmd->seq_end_offset) {
  44. cmd->seq_start_offset = cmd->write_data_done;
  45. cmd->seq_end_offset = (cmd->se_cmd.data_length >
  46. conn->sess->sess_ops->MaxBurstLength) ?
  47. (cmd->write_data_done +
  48. conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length;
  49. } else {
  50. cmd->seq_start_offset = cmd->seq_end_offset;
  51. cmd->seq_end_offset = ((cmd->seq_end_offset +
  52. conn->sess->sess_ops->MaxBurstLength) >=
  53. cmd->se_cmd.data_length) ? cmd->se_cmd.data_length :
  54. (cmd->seq_end_offset +
  55. conn->sess->sess_ops->MaxBurstLength);
  56. }
  57. }
  58. static int iscsit_dataout_within_command_recovery_check(
  59. struct iscsi_cmd *cmd,
  60. unsigned char *buf)
  61. {
  62. struct iscsi_conn *conn = cmd->conn;
  63. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  64. u32 payload_length = ntoh24(hdr->dlength);
  65. /*
  66. * We do the within-command recovery checks here as it is
  67. * the first function called in iscsi_check_pre_dataout().
  68. * Basically, if we are in within-command recovery and
  69. * the PDU does not contain the offset the sequence needs,
  70. * dump the payload.
  71. *
  72. * This only applies to DataPDUInOrder=Yes, for
  73. * DataPDUInOrder=No we only re-request the failed PDU
  74. * and check that all PDUs in a sequence are received
  75. * upon end of sequence.
  76. */
  77. if (conn->sess->sess_ops->DataSequenceInOrder) {
  78. if ((cmd->cmd_flags & ICF_WITHIN_COMMAND_RECOVERY) &&
  79. cmd->write_data_done != be32_to_cpu(hdr->offset))
  80. goto dump;
  81. cmd->cmd_flags &= ~ICF_WITHIN_COMMAND_RECOVERY;
  82. } else {
  83. struct iscsi_seq *seq;
  84. seq = iscsit_get_seq_holder(cmd, be32_to_cpu(hdr->offset),
  85. payload_length);
  86. if (!seq)
  87. return DATAOUT_CANNOT_RECOVER;
  88. /*
  89. * Set the struct iscsi_seq pointer to reuse later.
  90. */
  91. cmd->seq_ptr = seq;
  92. if (conn->sess->sess_ops->DataPDUInOrder) {
  93. if (seq->status ==
  94. DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY &&
  95. (seq->offset != be32_to_cpu(hdr->offset) ||
  96. seq->data_sn != be32_to_cpu(hdr->datasn)))
  97. goto dump;
  98. } else {
  99. if (seq->status ==
  100. DATAOUT_SEQUENCE_WITHIN_COMMAND_RECOVERY &&
  101. seq->data_sn != be32_to_cpu(hdr->datasn))
  102. goto dump;
  103. }
  104. if (seq->status == DATAOUT_SEQUENCE_COMPLETE)
  105. goto dump;
  106. if (seq->status != DATAOUT_SEQUENCE_COMPLETE)
  107. seq->status = 0;
  108. }
  109. return DATAOUT_NORMAL;
  110. dump:
  111. pr_err("Dumping DataOUT PDU Offset: %u Length: %d DataSN:"
  112. " 0x%08x\n", hdr->offset, payload_length, hdr->datasn);
  113. return iscsit_dump_data_payload(conn, payload_length, 1);
  114. }
  115. static int iscsit_dataout_check_unsolicited_sequence(
  116. struct iscsi_cmd *cmd,
  117. unsigned char *buf)
  118. {
  119. u32 first_burst_len;
  120. struct iscsi_conn *conn = cmd->conn;
  121. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  122. u32 payload_length = ntoh24(hdr->dlength);
  123. if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
  124. ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
  125. pr_err("Command ITT: 0x%08x with Offset: %u,"
  126. " Length: %u outside of Unsolicited Sequence %u:%u while"
  127. " DataSequenceInOrder=Yes.\n", cmd->init_task_tag,
  128. be32_to_cpu(hdr->offset), payload_length, cmd->seq_start_offset,
  129. cmd->seq_end_offset);
  130. return DATAOUT_CANNOT_RECOVER;
  131. }
  132. first_burst_len = (cmd->first_burst_len + payload_length);
  133. if (first_burst_len > conn->sess->sess_ops->FirstBurstLength) {
  134. pr_err("Total %u bytes exceeds FirstBurstLength: %u"
  135. " for this Unsolicited DataOut Burst.\n",
  136. first_burst_len, conn->sess->sess_ops->FirstBurstLength);
  137. transport_send_check_condition_and_sense(&cmd->se_cmd,
  138. TCM_INCORRECT_AMOUNT_OF_DATA, 0);
  139. return DATAOUT_CANNOT_RECOVER;
  140. }
  141. /*
  142. * Perform various MaxBurstLength and ISCSI_FLAG_CMD_FINAL sanity
  143. * checks for the current Unsolicited DataOUT Sequence.
  144. */
  145. if (hdr->flags & ISCSI_FLAG_CMD_FINAL) {
  146. /*
  147. * Ignore ISCSI_FLAG_CMD_FINAL checks while DataPDUInOrder=No, end of
  148. * sequence checks are handled in
  149. * iscsit_dataout_datapduinorder_no_fbit().
  150. */
  151. if (!conn->sess->sess_ops->DataPDUInOrder)
  152. goto out;
  153. if ((first_burst_len != cmd->se_cmd.data_length) &&
  154. (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) {
  155. pr_err("Unsolicited non-immediate data"
  156. " received %u does not equal FirstBurstLength: %u, and"
  157. " does not equal ExpXferLen %u.\n", first_burst_len,
  158. conn->sess->sess_ops->FirstBurstLength,
  159. cmd->se_cmd.data_length);
  160. transport_send_check_condition_and_sense(&cmd->se_cmd,
  161. TCM_INCORRECT_AMOUNT_OF_DATA, 0);
  162. return DATAOUT_CANNOT_RECOVER;
  163. }
  164. } else {
  165. if (first_burst_len == conn->sess->sess_ops->FirstBurstLength) {
  166. pr_err("Command ITT: 0x%08x reached"
  167. " FirstBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
  168. " error.\n", cmd->init_task_tag,
  169. conn->sess->sess_ops->FirstBurstLength);
  170. return DATAOUT_CANNOT_RECOVER;
  171. }
  172. if (first_burst_len == cmd->se_cmd.data_length) {
  173. pr_err("Command ITT: 0x%08x reached"
  174. " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
  175. " error.\n", cmd->init_task_tag, cmd->se_cmd.data_length);
  176. return DATAOUT_CANNOT_RECOVER;
  177. }
  178. }
  179. out:
  180. return DATAOUT_NORMAL;
  181. }
  182. static int iscsit_dataout_check_sequence(
  183. struct iscsi_cmd *cmd,
  184. unsigned char *buf)
  185. {
  186. u32 next_burst_len;
  187. struct iscsi_conn *conn = cmd->conn;
  188. struct iscsi_seq *seq = NULL;
  189. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  190. u32 payload_length = ntoh24(hdr->dlength);
  191. /*
  192. * For DataSequenceInOrder=Yes: Check that the offset and offset+length
  193. * is within range as defined by iscsi_set_dataout_sequence_values().
  194. *
  195. * For DataSequenceInOrder=No: Check that an struct iscsi_seq exists for
  196. * offset+length tuple.
  197. */
  198. if (conn->sess->sess_ops->DataSequenceInOrder) {
  199. /*
  200. * Due to possibility of recovery DataOUT sent by the initiator
  201. * fullfilling an Recovery R2T, it's best to just dump the
  202. * payload here, instead of erroring out.
  203. */
  204. if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
  205. ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
  206. pr_err("Command ITT: 0x%08x with Offset: %u,"
  207. " Length: %u outside of Sequence %u:%u while"
  208. " DataSequenceInOrder=Yes.\n", cmd->init_task_tag,
  209. be32_to_cpu(hdr->offset), payload_length, cmd->seq_start_offset,
  210. cmd->seq_end_offset);
  211. if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
  212. return DATAOUT_CANNOT_RECOVER;
  213. return DATAOUT_WITHIN_COMMAND_RECOVERY;
  214. }
  215. next_burst_len = (cmd->next_burst_len + payload_length);
  216. } else {
  217. seq = iscsit_get_seq_holder(cmd, be32_to_cpu(hdr->offset),
  218. payload_length);
  219. if (!seq)
  220. return DATAOUT_CANNOT_RECOVER;
  221. /*
  222. * Set the struct iscsi_seq pointer to reuse later.
  223. */
  224. cmd->seq_ptr = seq;
  225. if (seq->status == DATAOUT_SEQUENCE_COMPLETE) {
  226. if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
  227. return DATAOUT_CANNOT_RECOVER;
  228. return DATAOUT_WITHIN_COMMAND_RECOVERY;
  229. }
  230. next_burst_len = (seq->next_burst_len + payload_length);
  231. }
  232. if (next_burst_len > conn->sess->sess_ops->MaxBurstLength) {
  233. pr_err("Command ITT: 0x%08x, NextBurstLength: %u and"
  234. " Length: %u exceeds MaxBurstLength: %u. protocol"
  235. " error.\n", cmd->init_task_tag,
  236. (next_burst_len - payload_length),
  237. payload_length, conn->sess->sess_ops->MaxBurstLength);
  238. return DATAOUT_CANNOT_RECOVER;
  239. }
  240. /*
  241. * Perform various MaxBurstLength and ISCSI_FLAG_CMD_FINAL sanity
  242. * checks for the current DataOUT Sequence.
  243. */
  244. if (hdr->flags & ISCSI_FLAG_CMD_FINAL) {
  245. /*
  246. * Ignore ISCSI_FLAG_CMD_FINAL checks while DataPDUInOrder=No, end of
  247. * sequence checks are handled in
  248. * iscsit_dataout_datapduinorder_no_fbit().
  249. */
  250. if (!conn->sess->sess_ops->DataPDUInOrder)
  251. goto out;
  252. if (conn->sess->sess_ops->DataSequenceInOrder) {
  253. if ((next_burst_len <
  254. conn->sess->sess_ops->MaxBurstLength) &&
  255. ((cmd->write_data_done + payload_length) <
  256. cmd->se_cmd.data_length)) {
  257. pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
  258. " before end of DataOUT sequence, protocol"
  259. " error.\n", cmd->init_task_tag);
  260. return DATAOUT_CANNOT_RECOVER;
  261. }
  262. } else {
  263. if (next_burst_len < seq->xfer_len) {
  264. pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
  265. " before end of DataOUT sequence, protocol"
  266. " error.\n", cmd->init_task_tag);
  267. return DATAOUT_CANNOT_RECOVER;
  268. }
  269. }
  270. } else {
  271. if (conn->sess->sess_ops->DataSequenceInOrder) {
  272. if (next_burst_len ==
  273. conn->sess->sess_ops->MaxBurstLength) {
  274. pr_err("Command ITT: 0x%08x reached"
  275. " MaxBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is"
  276. " not set, protocol error.", cmd->init_task_tag,
  277. conn->sess->sess_ops->MaxBurstLength);
  278. return DATAOUT_CANNOT_RECOVER;
  279. }
  280. if ((cmd->write_data_done + payload_length) ==
  281. cmd->se_cmd.data_length) {
  282. pr_err("Command ITT: 0x%08x reached"
  283. " last DataOUT PDU in sequence but ISCSI_FLAG_"
  284. "CMD_FINAL is not set, protocol error.\n",
  285. cmd->init_task_tag);
  286. return DATAOUT_CANNOT_RECOVER;
  287. }
  288. } else {
  289. if (next_burst_len == seq->xfer_len) {
  290. pr_err("Command ITT: 0x%08x reached"
  291. " last DataOUT PDU in sequence but ISCSI_FLAG_"
  292. "CMD_FINAL is not set, protocol error.\n",
  293. cmd->init_task_tag);
  294. return DATAOUT_CANNOT_RECOVER;
  295. }
  296. }
  297. }
  298. out:
  299. return DATAOUT_NORMAL;
  300. }
  301. static int iscsit_dataout_check_datasn(
  302. struct iscsi_cmd *cmd,
  303. unsigned char *buf)
  304. {
  305. u32 data_sn = 0;
  306. struct iscsi_conn *conn = cmd->conn;
  307. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  308. u32 payload_length = ntoh24(hdr->dlength);
  309. /*
  310. * Considering the target has no method of re-requesting DataOUT
  311. * by DataSN, if we receieve a greater DataSN than expected we
  312. * assume the functions for DataPDUInOrder=[Yes,No] below will
  313. * handle it.
  314. *
  315. * If the DataSN is less than expected, dump the payload.
  316. */
  317. if (conn->sess->sess_ops->DataSequenceInOrder)
  318. data_sn = cmd->data_sn;
  319. else {
  320. struct iscsi_seq *seq = cmd->seq_ptr;
  321. data_sn = seq->data_sn;
  322. }
  323. if (be32_to_cpu(hdr->datasn) > data_sn) {
  324. pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
  325. " higher than expected 0x%08x.\n", cmd->init_task_tag,
  326. be32_to_cpu(hdr->datasn), data_sn);
  327. goto recover;
  328. } else if (be32_to_cpu(hdr->datasn) < data_sn) {
  329. pr_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
  330. " lower than expected 0x%08x, discarding payload.\n",
  331. cmd->init_task_tag, be32_to_cpu(hdr->datasn), data_sn);
  332. goto dump;
  333. }
  334. return DATAOUT_NORMAL;
  335. recover:
  336. if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
  337. pr_err("Unable to perform within-command recovery"
  338. " while ERL=0.\n");
  339. return DATAOUT_CANNOT_RECOVER;
  340. }
  341. dump:
  342. if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
  343. return DATAOUT_CANNOT_RECOVER;
  344. return DATAOUT_WITHIN_COMMAND_RECOVERY;
  345. }
  346. static int iscsit_dataout_pre_datapduinorder_yes(
  347. struct iscsi_cmd *cmd,
  348. unsigned char *buf)
  349. {
  350. int dump = 0, recovery = 0;
  351. struct iscsi_conn *conn = cmd->conn;
  352. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  353. u32 payload_length = ntoh24(hdr->dlength);
  354. /*
  355. * For DataSequenceInOrder=Yes: If the offset is greater than the global
  356. * DataPDUInOrder=Yes offset counter in struct iscsi_cmd a protcol error has
  357. * occurred and fail the connection.
  358. *
  359. * For DataSequenceInOrder=No: If the offset is greater than the per
  360. * sequence DataPDUInOrder=Yes offset counter in struct iscsi_seq a protocol
  361. * error has occurred and fail the connection.
  362. */
  363. if (conn->sess->sess_ops->DataSequenceInOrder) {
  364. if (be32_to_cpu(hdr->offset) != cmd->write_data_done) {
  365. pr_err("Command ITT: 0x%08x, received offset"
  366. " %u different than expected %u.\n", cmd->init_task_tag,
  367. be32_to_cpu(hdr->offset), cmd->write_data_done);
  368. recovery = 1;
  369. goto recover;
  370. }
  371. } else {
  372. struct iscsi_seq *seq = cmd->seq_ptr;
  373. if (be32_to_cpu(hdr->offset) > seq->offset) {
  374. pr_err("Command ITT: 0x%08x, received offset"
  375. " %u greater than expected %u.\n", cmd->init_task_tag,
  376. be32_to_cpu(hdr->offset), seq->offset);
  377. recovery = 1;
  378. goto recover;
  379. } else if (be32_to_cpu(hdr->offset) < seq->offset) {
  380. pr_err("Command ITT: 0x%08x, received offset"
  381. " %u less than expected %u, discarding payload.\n",
  382. cmd->init_task_tag, be32_to_cpu(hdr->offset),
  383. seq->offset);
  384. dump = 1;
  385. goto dump;
  386. }
  387. }
  388. return DATAOUT_NORMAL;
  389. recover:
  390. if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
  391. pr_err("Unable to perform within-command recovery"
  392. " while ERL=0.\n");
  393. return DATAOUT_CANNOT_RECOVER;
  394. }
  395. dump:
  396. if (iscsit_dump_data_payload(conn, payload_length, 1) < 0)
  397. return DATAOUT_CANNOT_RECOVER;
  398. return (recovery) ? iscsit_recover_dataout_sequence(cmd,
  399. be32_to_cpu(hdr->offset), payload_length) :
  400. (dump) ? DATAOUT_WITHIN_COMMAND_RECOVERY : DATAOUT_NORMAL;
  401. }
  402. static int iscsit_dataout_pre_datapduinorder_no(
  403. struct iscsi_cmd *cmd,
  404. unsigned char *buf)
  405. {
  406. struct iscsi_pdu *pdu;
  407. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  408. u32 payload_length = ntoh24(hdr->dlength);
  409. pdu = iscsit_get_pdu_holder(cmd, be32_to_cpu(hdr->offset),
  410. payload_length);
  411. if (!pdu)
  412. return DATAOUT_CANNOT_RECOVER;
  413. cmd->pdu_ptr = pdu;
  414. switch (pdu->status) {
  415. case ISCSI_PDU_NOT_RECEIVED:
  416. case ISCSI_PDU_CRC_FAILED:
  417. case ISCSI_PDU_TIMED_OUT:
  418. break;
  419. case ISCSI_PDU_RECEIVED_OK:
  420. pr_err("Command ITT: 0x%08x received already gotten"
  421. " Offset: %u, Length: %u\n", cmd->init_task_tag,
  422. be32_to_cpu(hdr->offset), payload_length);
  423. return iscsit_dump_data_payload(cmd->conn, payload_length, 1);
  424. default:
  425. return DATAOUT_CANNOT_RECOVER;
  426. }
  427. return DATAOUT_NORMAL;
  428. }
  429. static int iscsit_dataout_update_r2t(struct iscsi_cmd *cmd, u32 offset, u32 length)
  430. {
  431. struct iscsi_r2t *r2t;
  432. if (cmd->unsolicited_data)
  433. return 0;
  434. r2t = iscsit_get_r2t_for_eos(cmd, offset, length);
  435. if (!r2t)
  436. return -1;
  437. spin_lock_bh(&cmd->r2t_lock);
  438. r2t->seq_complete = 1;
  439. cmd->outstanding_r2ts--;
  440. spin_unlock_bh(&cmd->r2t_lock);
  441. return 0;
  442. }
  443. static int iscsit_dataout_update_datapduinorder_no(
  444. struct iscsi_cmd *cmd,
  445. u32 data_sn,
  446. int f_bit)
  447. {
  448. int ret = 0;
  449. struct iscsi_pdu *pdu = cmd->pdu_ptr;
  450. pdu->data_sn = data_sn;
  451. switch (pdu->status) {
  452. case ISCSI_PDU_NOT_RECEIVED:
  453. pdu->status = ISCSI_PDU_RECEIVED_OK;
  454. break;
  455. case ISCSI_PDU_CRC_FAILED:
  456. pdu->status = ISCSI_PDU_RECEIVED_OK;
  457. break;
  458. case ISCSI_PDU_TIMED_OUT:
  459. pdu->status = ISCSI_PDU_RECEIVED_OK;
  460. break;
  461. default:
  462. return DATAOUT_CANNOT_RECOVER;
  463. }
  464. if (f_bit) {
  465. ret = iscsit_dataout_datapduinorder_no_fbit(cmd, pdu);
  466. if (ret == DATAOUT_CANNOT_RECOVER)
  467. return ret;
  468. }
  469. return DATAOUT_NORMAL;
  470. }
  471. static int iscsit_dataout_post_crc_passed(
  472. struct iscsi_cmd *cmd,
  473. unsigned char *buf)
  474. {
  475. int ret, send_r2t = 0;
  476. struct iscsi_conn *conn = cmd->conn;
  477. struct iscsi_seq *seq = NULL;
  478. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  479. u32 payload_length = ntoh24(hdr->dlength);
  480. if (cmd->unsolicited_data) {
  481. if ((cmd->first_burst_len + payload_length) ==
  482. conn->sess->sess_ops->FirstBurstLength) {
  483. if (iscsit_dataout_update_r2t(cmd, be32_to_cpu(hdr->offset),
  484. payload_length) < 0)
  485. return DATAOUT_CANNOT_RECOVER;
  486. send_r2t = 1;
  487. }
  488. if (!conn->sess->sess_ops->DataPDUInOrder) {
  489. ret = iscsit_dataout_update_datapduinorder_no(cmd,
  490. be32_to_cpu(hdr->datasn),
  491. (hdr->flags & ISCSI_FLAG_CMD_FINAL));
  492. if (ret == DATAOUT_CANNOT_RECOVER)
  493. return ret;
  494. }
  495. cmd->first_burst_len += payload_length;
  496. if (conn->sess->sess_ops->DataSequenceInOrder)
  497. cmd->data_sn++;
  498. else {
  499. seq = cmd->seq_ptr;
  500. seq->data_sn++;
  501. seq->offset += payload_length;
  502. }
  503. if (send_r2t) {
  504. if (seq)
  505. seq->status = DATAOUT_SEQUENCE_COMPLETE;
  506. cmd->first_burst_len = 0;
  507. cmd->unsolicited_data = 0;
  508. }
  509. } else {
  510. if (conn->sess->sess_ops->DataSequenceInOrder) {
  511. if ((cmd->next_burst_len + payload_length) ==
  512. conn->sess->sess_ops->MaxBurstLength) {
  513. if (iscsit_dataout_update_r2t(cmd,
  514. be32_to_cpu(hdr->offset),
  515. payload_length) < 0)
  516. return DATAOUT_CANNOT_RECOVER;
  517. send_r2t = 1;
  518. }
  519. if (!conn->sess->sess_ops->DataPDUInOrder) {
  520. ret = iscsit_dataout_update_datapduinorder_no(
  521. cmd, be32_to_cpu(hdr->datasn),
  522. (hdr->flags & ISCSI_FLAG_CMD_FINAL));
  523. if (ret == DATAOUT_CANNOT_RECOVER)
  524. return ret;
  525. }
  526. cmd->next_burst_len += payload_length;
  527. cmd->data_sn++;
  528. if (send_r2t)
  529. cmd->next_burst_len = 0;
  530. } else {
  531. seq = cmd->seq_ptr;
  532. if ((seq->next_burst_len + payload_length) ==
  533. seq->xfer_len) {
  534. if (iscsit_dataout_update_r2t(cmd,
  535. be32_to_cpu(hdr->offset),
  536. payload_length) < 0)
  537. return DATAOUT_CANNOT_RECOVER;
  538. send_r2t = 1;
  539. }
  540. if (!conn->sess->sess_ops->DataPDUInOrder) {
  541. ret = iscsit_dataout_update_datapduinorder_no(
  542. cmd, be32_to_cpu(hdr->datasn),
  543. (hdr->flags & ISCSI_FLAG_CMD_FINAL));
  544. if (ret == DATAOUT_CANNOT_RECOVER)
  545. return ret;
  546. }
  547. seq->data_sn++;
  548. seq->offset += payload_length;
  549. seq->next_burst_len += payload_length;
  550. if (send_r2t) {
  551. seq->next_burst_len = 0;
  552. seq->status = DATAOUT_SEQUENCE_COMPLETE;
  553. }
  554. }
  555. }
  556. if (send_r2t && conn->sess->sess_ops->DataSequenceInOrder)
  557. cmd->data_sn = 0;
  558. cmd->write_data_done += payload_length;
  559. if (cmd->write_data_done == cmd->se_cmd.data_length)
  560. return DATAOUT_SEND_TO_TRANSPORT;
  561. else if (send_r2t)
  562. return DATAOUT_SEND_R2T;
  563. else
  564. return DATAOUT_NORMAL;
  565. }
  566. static int iscsit_dataout_post_crc_failed(
  567. struct iscsi_cmd *cmd,
  568. unsigned char *buf)
  569. {
  570. struct iscsi_conn *conn = cmd->conn;
  571. struct iscsi_pdu *pdu;
  572. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  573. u32 payload_length = ntoh24(hdr->dlength);
  574. if (conn->sess->sess_ops->DataPDUInOrder)
  575. goto recover;
  576. /*
  577. * The rest of this function is only called when DataPDUInOrder=No.
  578. */
  579. pdu = cmd->pdu_ptr;
  580. switch (pdu->status) {
  581. case ISCSI_PDU_NOT_RECEIVED:
  582. pdu->status = ISCSI_PDU_CRC_FAILED;
  583. break;
  584. case ISCSI_PDU_CRC_FAILED:
  585. break;
  586. case ISCSI_PDU_TIMED_OUT:
  587. pdu->status = ISCSI_PDU_CRC_FAILED;
  588. break;
  589. default:
  590. return DATAOUT_CANNOT_RECOVER;
  591. }
  592. recover:
  593. return iscsit_recover_dataout_sequence(cmd, be32_to_cpu(hdr->offset),
  594. payload_length);
  595. }
  596. /*
  597. * Called from iscsit_handle_data_out() before DataOUT Payload is received
  598. * and CRC computed.
  599. */
  600. int iscsit_check_pre_dataout(
  601. struct iscsi_cmd *cmd,
  602. unsigned char *buf)
  603. {
  604. int ret;
  605. struct iscsi_conn *conn = cmd->conn;
  606. ret = iscsit_dataout_within_command_recovery_check(cmd, buf);
  607. if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
  608. (ret == DATAOUT_CANNOT_RECOVER))
  609. return ret;
  610. ret = iscsit_dataout_check_datasn(cmd, buf);
  611. if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
  612. (ret == DATAOUT_CANNOT_RECOVER))
  613. return ret;
  614. if (cmd->unsolicited_data) {
  615. ret = iscsit_dataout_check_unsolicited_sequence(cmd, buf);
  616. if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
  617. (ret == DATAOUT_CANNOT_RECOVER))
  618. return ret;
  619. } else {
  620. ret = iscsit_dataout_check_sequence(cmd, buf);
  621. if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
  622. (ret == DATAOUT_CANNOT_RECOVER))
  623. return ret;
  624. }
  625. return (conn->sess->sess_ops->DataPDUInOrder) ?
  626. iscsit_dataout_pre_datapduinorder_yes(cmd, buf) :
  627. iscsit_dataout_pre_datapduinorder_no(cmd, buf);
  628. }
  629. /*
  630. * Called from iscsit_handle_data_out() after DataOUT Payload is received
  631. * and CRC computed.
  632. */
  633. int iscsit_check_post_dataout(
  634. struct iscsi_cmd *cmd,
  635. unsigned char *buf,
  636. u8 data_crc_failed)
  637. {
  638. struct iscsi_conn *conn = cmd->conn;
  639. cmd->dataout_timeout_retries = 0;
  640. if (!data_crc_failed)
  641. return iscsit_dataout_post_crc_passed(cmd, buf);
  642. else {
  643. if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
  644. pr_err("Unable to recover from DataOUT CRC"
  645. " failure while ERL=0, closing session.\n");
  646. iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR,
  647. buf);
  648. return DATAOUT_CANNOT_RECOVER;
  649. }
  650. iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR, buf);
  651. return iscsit_dataout_post_crc_failed(cmd, buf);
  652. }
  653. }
  654. void iscsit_handle_time2retain_timeout(struct timer_list *t)
  655. {
  656. struct iscsi_session *sess = from_timer(sess, t, time2retain_timer);
  657. struct iscsi_portal_group *tpg = sess->tpg;
  658. struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
  659. spin_lock_bh(&se_tpg->session_lock);
  660. if (sess->time2retain_timer_flags & ISCSI_TF_STOP) {
  661. spin_unlock_bh(&se_tpg->session_lock);
  662. return;
  663. }
  664. if (atomic_read(&sess->session_reinstatement)) {
  665. pr_err("Exiting Time2Retain handler because"
  666. " session_reinstatement=1\n");
  667. spin_unlock_bh(&se_tpg->session_lock);
  668. return;
  669. }
  670. sess->time2retain_timer_flags |= ISCSI_TF_EXPIRED;
  671. pr_err("Time2Retain timer expired for SID: %u, cleaning up"
  672. " iSCSI session.\n", sess->sid);
  673. iscsit_fill_cxn_timeout_err_stats(sess);
  674. spin_unlock_bh(&se_tpg->session_lock);
  675. iscsit_close_session(sess);
  676. }
  677. void iscsit_start_time2retain_handler(struct iscsi_session *sess)
  678. {
  679. int tpg_active;
  680. /*
  681. * Only start Time2Retain timer when the associated TPG is still in
  682. * an ACTIVE (eg: not disabled or shutdown) state.
  683. */
  684. spin_lock(&sess->tpg->tpg_state_lock);
  685. tpg_active = (sess->tpg->tpg_state == TPG_STATE_ACTIVE);
  686. spin_unlock(&sess->tpg->tpg_state_lock);
  687. if (!tpg_active)
  688. return;
  689. if (sess->time2retain_timer_flags & ISCSI_TF_RUNNING)
  690. return;
  691. pr_debug("Starting Time2Retain timer for %u seconds on"
  692. " SID: %u\n", sess->sess_ops->DefaultTime2Retain, sess->sid);
  693. sess->time2retain_timer_flags &= ~ISCSI_TF_STOP;
  694. sess->time2retain_timer_flags |= ISCSI_TF_RUNNING;
  695. mod_timer(&sess->time2retain_timer,
  696. jiffies + sess->sess_ops->DefaultTime2Retain * HZ);
  697. }
  698. int iscsit_stop_time2retain_timer(struct iscsi_session *sess)
  699. {
  700. struct iscsi_portal_group *tpg = sess->tpg;
  701. struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
  702. lockdep_assert_held(&se_tpg->session_lock);
  703. if (sess->time2retain_timer_flags & ISCSI_TF_EXPIRED)
  704. return -1;
  705. if (!(sess->time2retain_timer_flags & ISCSI_TF_RUNNING))
  706. return 0;
  707. sess->time2retain_timer_flags |= ISCSI_TF_STOP;
  708. spin_unlock(&se_tpg->session_lock);
  709. del_timer_sync(&sess->time2retain_timer);
  710. spin_lock(&se_tpg->session_lock);
  711. sess->time2retain_timer_flags &= ~ISCSI_TF_RUNNING;
  712. pr_debug("Stopped Time2Retain Timer for SID: %u\n",
  713. sess->sid);
  714. return 0;
  715. }
  716. void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *conn)
  717. {
  718. spin_lock_bh(&conn->state_lock);
  719. if (atomic_read(&conn->connection_exit)) {
  720. spin_unlock_bh(&conn->state_lock);
  721. goto sleep;
  722. }
  723. if (atomic_read(&conn->transport_failed)) {
  724. spin_unlock_bh(&conn->state_lock);
  725. goto sleep;
  726. }
  727. spin_unlock_bh(&conn->state_lock);
  728. if (conn->tx_thread && conn->tx_thread_active)
  729. send_sig(SIGINT, conn->tx_thread, 1);
  730. if (conn->rx_thread && conn->rx_thread_active)
  731. send_sig(SIGINT, conn->rx_thread, 1);
  732. sleep:
  733. wait_for_completion(&conn->conn_wait_rcfr_comp);
  734. complete(&conn->conn_post_wait_comp);
  735. }
  736. void iscsit_cause_connection_reinstatement(struct iscsi_conn *conn, int sleep)
  737. {
  738. spin_lock_bh(&conn->state_lock);
  739. if (atomic_read(&conn->connection_exit)) {
  740. spin_unlock_bh(&conn->state_lock);
  741. return;
  742. }
  743. if (atomic_read(&conn->transport_failed)) {
  744. spin_unlock_bh(&conn->state_lock);
  745. return;
  746. }
  747. if (atomic_read(&conn->connection_reinstatement)) {
  748. spin_unlock_bh(&conn->state_lock);
  749. return;
  750. }
  751. if (conn->tx_thread && conn->tx_thread_active)
  752. send_sig(SIGINT, conn->tx_thread, 1);
  753. if (conn->rx_thread && conn->rx_thread_active)
  754. send_sig(SIGINT, conn->rx_thread, 1);
  755. atomic_set(&conn->connection_reinstatement, 1);
  756. if (!sleep) {
  757. spin_unlock_bh(&conn->state_lock);
  758. return;
  759. }
  760. atomic_set(&conn->sleep_on_conn_wait_comp, 1);
  761. spin_unlock_bh(&conn->state_lock);
  762. wait_for_completion(&conn->conn_wait_comp);
  763. complete(&conn->conn_post_wait_comp);
  764. }
  765. EXPORT_SYMBOL(iscsit_cause_connection_reinstatement);
  766. void iscsit_fall_back_to_erl0(struct iscsi_session *sess)
  767. {
  768. pr_debug("Falling back to ErrorRecoveryLevel=0 for SID:"
  769. " %u\n", sess->sid);
  770. atomic_set(&sess->session_fall_back_to_erl0, 1);
  771. }
  772. static void iscsit_handle_connection_cleanup(struct iscsi_conn *conn)
  773. {
  774. struct iscsi_session *sess = conn->sess;
  775. if ((sess->sess_ops->ErrorRecoveryLevel == 2) &&
  776. !atomic_read(&sess->session_reinstatement) &&
  777. !atomic_read(&sess->session_fall_back_to_erl0))
  778. iscsit_connection_recovery_transport_reset(conn);
  779. else {
  780. pr_debug("Performing cleanup for failed iSCSI"
  781. " Connection ID: %hu from %s\n", conn->cid,
  782. sess->sess_ops->InitiatorName);
  783. iscsit_close_connection(conn);
  784. }
  785. }
  786. void iscsit_take_action_for_connection_exit(struct iscsi_conn *conn, bool *conn_freed)
  787. {
  788. *conn_freed = false;
  789. spin_lock_bh(&conn->state_lock);
  790. if (atomic_read(&conn->connection_exit)) {
  791. spin_unlock_bh(&conn->state_lock);
  792. return;
  793. }
  794. atomic_set(&conn->connection_exit, 1);
  795. if (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT) {
  796. spin_unlock_bh(&conn->state_lock);
  797. iscsit_close_connection(conn);
  798. *conn_freed = true;
  799. return;
  800. }
  801. if (conn->conn_state == TARG_CONN_STATE_CLEANUP_WAIT) {
  802. spin_unlock_bh(&conn->state_lock);
  803. return;
  804. }
  805. pr_debug("Moving to TARG_CONN_STATE_CLEANUP_WAIT.\n");
  806. conn->conn_state = TARG_CONN_STATE_CLEANUP_WAIT;
  807. spin_unlock_bh(&conn->state_lock);
  808. iscsit_handle_connection_cleanup(conn);
  809. *conn_freed = true;
  810. }