iscsi_target_util.c 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*******************************************************************************
  3. * This file contains the iSCSI Target specific utility functions.
  4. *
  5. * (c) Copyright 2007-2013 Datera, Inc.
  6. *
  7. * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
  8. *
  9. ******************************************************************************/
  10. #include <linux/list.h>
  11. #include <linux/sched/signal.h>
  12. #include <net/ipv6.h> /* ipv6_addr_equal() */
  13. #include <scsi/scsi_tcq.h>
  14. #include <scsi/iscsi_proto.h>
  15. #include <target/target_core_base.h>
  16. #include <target/target_core_fabric.h>
  17. #include <target/iscsi/iscsi_transport.h>
  18. #include <target/iscsi/iscsi_target_core.h>
  19. #include "iscsi_target_parameters.h"
  20. #include "iscsi_target_seq_pdu_list.h"
  21. #include "iscsi_target_datain_values.h"
  22. #include "iscsi_target_erl0.h"
  23. #include "iscsi_target_erl1.h"
  24. #include "iscsi_target_erl2.h"
  25. #include "iscsi_target_tpg.h"
  26. #include "iscsi_target_util.h"
  27. #include "iscsi_target.h"
  28. #define PRINT_BUFF(buff, len) \
  29. { \
  30. int zzz; \
  31. \
  32. pr_debug("%d:\n", __LINE__); \
  33. for (zzz = 0; zzz < len; zzz++) { \
  34. if (zzz % 16 == 0) { \
  35. if (zzz) \
  36. pr_debug("\n"); \
  37. pr_debug("%4i: ", zzz); \
  38. } \
  39. pr_debug("%02x ", (unsigned char) (buff)[zzz]); \
  40. } \
  41. if ((len + 1) % 16) \
  42. pr_debug("\n"); \
  43. }
  44. extern struct list_head g_tiqn_list;
  45. extern spinlock_t tiqn_lock;
  46. int iscsit_add_r2t_to_list(
  47. struct iscsi_cmd *cmd,
  48. u32 offset,
  49. u32 xfer_len,
  50. int recovery,
  51. u32 r2t_sn)
  52. {
  53. struct iscsi_r2t *r2t;
  54. lockdep_assert_held(&cmd->r2t_lock);
  55. WARN_ON_ONCE((s32)xfer_len < 0);
  56. r2t = kmem_cache_zalloc(lio_r2t_cache, GFP_ATOMIC);
  57. if (!r2t) {
  58. pr_err("Unable to allocate memory for struct iscsi_r2t.\n");
  59. return -1;
  60. }
  61. INIT_LIST_HEAD(&r2t->r2t_list);
  62. r2t->recovery_r2t = recovery;
  63. r2t->r2t_sn = (!r2t_sn) ? cmd->r2t_sn++ : r2t_sn;
  64. r2t->offset = offset;
  65. r2t->xfer_len = xfer_len;
  66. list_add_tail(&r2t->r2t_list, &cmd->cmd_r2t_list);
  67. spin_unlock_bh(&cmd->r2t_lock);
  68. iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, ISTATE_SEND_R2T);
  69. spin_lock_bh(&cmd->r2t_lock);
  70. return 0;
  71. }
  72. struct iscsi_r2t *iscsit_get_r2t_for_eos(
  73. struct iscsi_cmd *cmd,
  74. u32 offset,
  75. u32 length)
  76. {
  77. struct iscsi_r2t *r2t;
  78. spin_lock_bh(&cmd->r2t_lock);
  79. list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
  80. if ((r2t->offset <= offset) &&
  81. (r2t->offset + r2t->xfer_len) >= (offset + length)) {
  82. spin_unlock_bh(&cmd->r2t_lock);
  83. return r2t;
  84. }
  85. }
  86. spin_unlock_bh(&cmd->r2t_lock);
  87. pr_err("Unable to locate R2T for Offset: %u, Length:"
  88. " %u\n", offset, length);
  89. return NULL;
  90. }
  91. struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsi_cmd *cmd)
  92. {
  93. struct iscsi_r2t *r2t;
  94. spin_lock_bh(&cmd->r2t_lock);
  95. list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
  96. if (!r2t->sent_r2t) {
  97. spin_unlock_bh(&cmd->r2t_lock);
  98. return r2t;
  99. }
  100. }
  101. spin_unlock_bh(&cmd->r2t_lock);
  102. pr_err("Unable to locate next R2T to send for ITT:"
  103. " 0x%08x.\n", cmd->init_task_tag);
  104. return NULL;
  105. }
  106. void iscsit_free_r2t(struct iscsi_r2t *r2t, struct iscsi_cmd *cmd)
  107. {
  108. lockdep_assert_held(&cmd->r2t_lock);
  109. list_del(&r2t->r2t_list);
  110. kmem_cache_free(lio_r2t_cache, r2t);
  111. }
  112. void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd)
  113. {
  114. struct iscsi_r2t *r2t, *r2t_tmp;
  115. spin_lock_bh(&cmd->r2t_lock);
  116. list_for_each_entry_safe(r2t, r2t_tmp, &cmd->cmd_r2t_list, r2t_list)
  117. iscsit_free_r2t(r2t, cmd);
  118. spin_unlock_bh(&cmd->r2t_lock);
  119. }
  120. static int iscsit_wait_for_tag(struct se_session *se_sess, int state, int *cpup)
  121. {
  122. int tag = -1;
  123. DEFINE_SBQ_WAIT(wait);
  124. struct sbq_wait_state *ws;
  125. struct sbitmap_queue *sbq;
  126. if (state == TASK_RUNNING)
  127. return tag;
  128. sbq = &se_sess->sess_tag_pool;
  129. ws = &sbq->ws[0];
  130. for (;;) {
  131. sbitmap_prepare_to_wait(sbq, ws, &wait, state);
  132. if (signal_pending_state(state, current))
  133. break;
  134. tag = sbitmap_queue_get(sbq, cpup);
  135. if (tag >= 0)
  136. break;
  137. schedule();
  138. }
  139. sbitmap_finish_wait(sbq, ws, &wait);
  140. return tag;
  141. }
  142. /*
  143. * May be called from software interrupt (timer) context for allocating
  144. * iSCSI NopINs.
  145. */
  146. struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state)
  147. {
  148. struct iscsi_cmd *cmd;
  149. struct se_session *se_sess = conn->sess->se_sess;
  150. int size, tag, cpu;
  151. tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
  152. if (tag < 0)
  153. tag = iscsit_wait_for_tag(se_sess, state, &cpu);
  154. if (tag < 0)
  155. return NULL;
  156. size = sizeof(struct iscsi_cmd) + conn->conn_transport->priv_size;
  157. cmd = (struct iscsi_cmd *)(se_sess->sess_cmd_map + (tag * size));
  158. memset(cmd, 0, size);
  159. cmd->se_cmd.map_tag = tag;
  160. cmd->se_cmd.map_cpu = cpu;
  161. cmd->conn = conn;
  162. cmd->data_direction = DMA_NONE;
  163. INIT_LIST_HEAD(&cmd->i_conn_node);
  164. INIT_LIST_HEAD(&cmd->datain_list);
  165. INIT_LIST_HEAD(&cmd->cmd_r2t_list);
  166. spin_lock_init(&cmd->datain_lock);
  167. spin_lock_init(&cmd->dataout_timeout_lock);
  168. spin_lock_init(&cmd->istate_lock);
  169. spin_lock_init(&cmd->error_lock);
  170. spin_lock_init(&cmd->r2t_lock);
  171. timer_setup(&cmd->dataout_timer, iscsit_handle_dataout_timeout, 0);
  172. return cmd;
  173. }
  174. EXPORT_SYMBOL(iscsit_allocate_cmd);
  175. struct iscsi_seq *iscsit_get_seq_holder_for_datain(
  176. struct iscsi_cmd *cmd,
  177. u32 seq_send_order)
  178. {
  179. u32 i;
  180. for (i = 0; i < cmd->seq_count; i++)
  181. if (cmd->seq_list[i].seq_send_order == seq_send_order)
  182. return &cmd->seq_list[i];
  183. return NULL;
  184. }
  185. struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *cmd)
  186. {
  187. u32 i;
  188. if (!cmd->seq_list) {
  189. pr_err("struct iscsi_cmd->seq_list is NULL!\n");
  190. return NULL;
  191. }
  192. for (i = 0; i < cmd->seq_count; i++) {
  193. if (cmd->seq_list[i].type != SEQTYPE_NORMAL)
  194. continue;
  195. if (cmd->seq_list[i].seq_send_order == cmd->seq_send_order) {
  196. cmd->seq_send_order++;
  197. return &cmd->seq_list[i];
  198. }
  199. }
  200. return NULL;
  201. }
  202. struct iscsi_r2t *iscsit_get_holder_for_r2tsn(
  203. struct iscsi_cmd *cmd,
  204. u32 r2t_sn)
  205. {
  206. struct iscsi_r2t *r2t;
  207. spin_lock_bh(&cmd->r2t_lock);
  208. list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) {
  209. if (r2t->r2t_sn == r2t_sn) {
  210. spin_unlock_bh(&cmd->r2t_lock);
  211. return r2t;
  212. }
  213. }
  214. spin_unlock_bh(&cmd->r2t_lock);
  215. return NULL;
  216. }
  217. static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cmdsn)
  218. {
  219. u32 max_cmdsn;
  220. int ret;
  221. /*
  222. * This is the proper method of checking received CmdSN against
  223. * ExpCmdSN and MaxCmdSN values, as well as accounting for out
  224. * or order CmdSNs due to multiple connection sessions and/or
  225. * CRC failures.
  226. */
  227. max_cmdsn = atomic_read(&sess->max_cmd_sn);
  228. if (iscsi_sna_gt(cmdsn, max_cmdsn)) {
  229. pr_err("Received CmdSN: 0x%08x is greater than"
  230. " MaxCmdSN: 0x%08x, ignoring.\n", cmdsn, max_cmdsn);
  231. ret = CMDSN_MAXCMDSN_OVERRUN;
  232. } else if (cmdsn == sess->exp_cmd_sn) {
  233. sess->exp_cmd_sn++;
  234. pr_debug("Received CmdSN matches ExpCmdSN,"
  235. " incremented ExpCmdSN to: 0x%08x\n",
  236. sess->exp_cmd_sn);
  237. ret = CMDSN_NORMAL_OPERATION;
  238. } else if (iscsi_sna_gt(cmdsn, sess->exp_cmd_sn)) {
  239. pr_debug("Received CmdSN: 0x%08x is greater"
  240. " than ExpCmdSN: 0x%08x, not acknowledging.\n",
  241. cmdsn, sess->exp_cmd_sn);
  242. ret = CMDSN_HIGHER_THAN_EXP;
  243. } else {
  244. pr_err("Received CmdSN: 0x%08x is less than"
  245. " ExpCmdSN: 0x%08x, ignoring.\n", cmdsn,
  246. sess->exp_cmd_sn);
  247. ret = CMDSN_LOWER_THAN_EXP;
  248. }
  249. return ret;
  250. }
  251. /*
  252. * Commands may be received out of order if MC/S is in use.
  253. * Ensure they are executed in CmdSN order.
  254. */
  255. int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
  256. unsigned char *buf, __be32 cmdsn)
  257. {
  258. int ret, cmdsn_ret;
  259. bool reject = false;
  260. u8 reason = ISCSI_REASON_BOOKMARK_NO_RESOURCES;
  261. mutex_lock(&conn->sess->cmdsn_mutex);
  262. cmdsn_ret = iscsit_check_received_cmdsn(conn->sess, be32_to_cpu(cmdsn));
  263. switch (cmdsn_ret) {
  264. case CMDSN_NORMAL_OPERATION:
  265. ret = iscsit_execute_cmd(cmd, 0);
  266. if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list))
  267. iscsit_execute_ooo_cmdsns(conn->sess);
  268. else if (ret < 0) {
  269. reject = true;
  270. ret = CMDSN_ERROR_CANNOT_RECOVER;
  271. }
  272. break;
  273. case CMDSN_HIGHER_THAN_EXP:
  274. ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn));
  275. if (ret < 0) {
  276. reject = true;
  277. ret = CMDSN_ERROR_CANNOT_RECOVER;
  278. break;
  279. }
  280. ret = CMDSN_HIGHER_THAN_EXP;
  281. break;
  282. case CMDSN_LOWER_THAN_EXP:
  283. case CMDSN_MAXCMDSN_OVERRUN:
  284. default:
  285. cmd->i_state = ISTATE_REMOVE;
  286. iscsit_add_cmd_to_immediate_queue(cmd, conn, cmd->i_state);
  287. /*
  288. * Existing callers for iscsit_sequence_cmd() will silently
  289. * ignore commands with CMDSN_LOWER_THAN_EXP, so force this
  290. * return for CMDSN_MAXCMDSN_OVERRUN as well..
  291. */
  292. ret = CMDSN_LOWER_THAN_EXP;
  293. break;
  294. }
  295. mutex_unlock(&conn->sess->cmdsn_mutex);
  296. if (reject)
  297. iscsit_reject_cmd(cmd, reason, buf);
  298. return ret;
  299. }
  300. EXPORT_SYMBOL(iscsit_sequence_cmd);
  301. int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf)
  302. {
  303. struct iscsi_conn *conn = cmd->conn;
  304. struct se_cmd *se_cmd = &cmd->se_cmd;
  305. struct iscsi_data *hdr = (struct iscsi_data *) buf;
  306. u32 payload_length = ntoh24(hdr->dlength);
  307. if (conn->sess->sess_ops->InitialR2T) {
  308. pr_err("Received unexpected unsolicited data"
  309. " while InitialR2T=Yes, protocol error.\n");
  310. transport_send_check_condition_and_sense(se_cmd,
  311. TCM_UNEXPECTED_UNSOLICITED_DATA, 0);
  312. return -1;
  313. }
  314. if ((cmd->first_burst_len + payload_length) >
  315. conn->sess->sess_ops->FirstBurstLength) {
  316. pr_err("Total %u bytes exceeds FirstBurstLength: %u"
  317. " for this Unsolicited DataOut Burst.\n",
  318. (cmd->first_burst_len + payload_length),
  319. conn->sess->sess_ops->FirstBurstLength);
  320. transport_send_check_condition_and_sense(se_cmd,
  321. TCM_INCORRECT_AMOUNT_OF_DATA, 0);
  322. return -1;
  323. }
  324. if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))
  325. return 0;
  326. if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
  327. ((cmd->first_burst_len + payload_length) !=
  328. conn->sess->sess_ops->FirstBurstLength)) {
  329. pr_err("Unsolicited non-immediate data received %u"
  330. " does not equal FirstBurstLength: %u, and does"
  331. " not equal ExpXferLen %u.\n",
  332. (cmd->first_burst_len + payload_length),
  333. conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
  334. transport_send_check_condition_and_sense(se_cmd,
  335. TCM_INCORRECT_AMOUNT_OF_DATA, 0);
  336. return -1;
  337. }
  338. return 0;
  339. }
  340. struct iscsi_cmd *iscsit_find_cmd_from_itt(
  341. struct iscsi_conn *conn,
  342. itt_t init_task_tag)
  343. {
  344. struct iscsi_cmd *cmd;
  345. spin_lock_bh(&conn->cmd_lock);
  346. list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
  347. if (cmd->init_task_tag == init_task_tag) {
  348. spin_unlock_bh(&conn->cmd_lock);
  349. return cmd;
  350. }
  351. }
  352. spin_unlock_bh(&conn->cmd_lock);
  353. pr_err("Unable to locate ITT: 0x%08x on CID: %hu",
  354. init_task_tag, conn->cid);
  355. return NULL;
  356. }
  357. EXPORT_SYMBOL(iscsit_find_cmd_from_itt);
  358. struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(
  359. struct iscsi_conn *conn,
  360. itt_t init_task_tag,
  361. u32 length)
  362. {
  363. struct iscsi_cmd *cmd;
  364. spin_lock_bh(&conn->cmd_lock);
  365. list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
  366. if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT)
  367. continue;
  368. if (cmd->init_task_tag == init_task_tag) {
  369. spin_unlock_bh(&conn->cmd_lock);
  370. return cmd;
  371. }
  372. }
  373. spin_unlock_bh(&conn->cmd_lock);
  374. pr_err("Unable to locate ITT: 0x%08x on CID: %hu,"
  375. " dumping payload\n", init_task_tag, conn->cid);
  376. if (length)
  377. iscsit_dump_data_payload(conn, length, 1);
  378. return NULL;
  379. }
  380. EXPORT_SYMBOL(iscsit_find_cmd_from_itt_or_dump);
  381. struct iscsi_cmd *iscsit_find_cmd_from_ttt(
  382. struct iscsi_conn *conn,
  383. u32 targ_xfer_tag)
  384. {
  385. struct iscsi_cmd *cmd = NULL;
  386. spin_lock_bh(&conn->cmd_lock);
  387. list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
  388. if (cmd->targ_xfer_tag == targ_xfer_tag) {
  389. spin_unlock_bh(&conn->cmd_lock);
  390. return cmd;
  391. }
  392. }
  393. spin_unlock_bh(&conn->cmd_lock);
  394. pr_err("Unable to locate TTT: 0x%08x on CID: %hu\n",
  395. targ_xfer_tag, conn->cid);
  396. return NULL;
  397. }
  398. int iscsit_find_cmd_for_recovery(
  399. struct iscsi_session *sess,
  400. struct iscsi_cmd **cmd_ptr,
  401. struct iscsi_conn_recovery **cr_ptr,
  402. itt_t init_task_tag)
  403. {
  404. struct iscsi_cmd *cmd = NULL;
  405. struct iscsi_conn_recovery *cr;
  406. /*
  407. * Scan through the inactive connection recovery list's command list.
  408. * If init_task_tag matches the command is still alligent.
  409. */
  410. spin_lock(&sess->cr_i_lock);
  411. list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
  412. spin_lock(&cr->conn_recovery_cmd_lock);
  413. list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
  414. if (cmd->init_task_tag == init_task_tag) {
  415. spin_unlock(&cr->conn_recovery_cmd_lock);
  416. spin_unlock(&sess->cr_i_lock);
  417. *cr_ptr = cr;
  418. *cmd_ptr = cmd;
  419. return -2;
  420. }
  421. }
  422. spin_unlock(&cr->conn_recovery_cmd_lock);
  423. }
  424. spin_unlock(&sess->cr_i_lock);
  425. /*
  426. * Scan through the active connection recovery list's command list.
  427. * If init_task_tag matches the command is ready to be reassigned.
  428. */
  429. spin_lock(&sess->cr_a_lock);
  430. list_for_each_entry(cr, &sess->cr_active_list, cr_list) {
  431. spin_lock(&cr->conn_recovery_cmd_lock);
  432. list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
  433. if (cmd->init_task_tag == init_task_tag) {
  434. spin_unlock(&cr->conn_recovery_cmd_lock);
  435. spin_unlock(&sess->cr_a_lock);
  436. *cr_ptr = cr;
  437. *cmd_ptr = cmd;
  438. return 0;
  439. }
  440. }
  441. spin_unlock(&cr->conn_recovery_cmd_lock);
  442. }
  443. spin_unlock(&sess->cr_a_lock);
  444. return -1;
  445. }
  446. void iscsit_add_cmd_to_immediate_queue(
  447. struct iscsi_cmd *cmd,
  448. struct iscsi_conn *conn,
  449. u8 state)
  450. {
  451. struct iscsi_queue_req *qr;
  452. qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
  453. if (!qr) {
  454. pr_err("Unable to allocate memory for"
  455. " struct iscsi_queue_req\n");
  456. return;
  457. }
  458. INIT_LIST_HEAD(&qr->qr_list);
  459. qr->cmd = cmd;
  460. qr->state = state;
  461. spin_lock_bh(&conn->immed_queue_lock);
  462. list_add_tail(&qr->qr_list, &conn->immed_queue_list);
  463. atomic_inc(&cmd->immed_queue_count);
  464. atomic_set(&conn->check_immediate_queue, 1);
  465. spin_unlock_bh(&conn->immed_queue_lock);
  466. wake_up(&conn->queues_wq);
  467. }
  468. EXPORT_SYMBOL(iscsit_add_cmd_to_immediate_queue);
  469. struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsi_conn *conn)
  470. {
  471. struct iscsi_queue_req *qr;
  472. spin_lock_bh(&conn->immed_queue_lock);
  473. if (list_empty(&conn->immed_queue_list)) {
  474. spin_unlock_bh(&conn->immed_queue_lock);
  475. return NULL;
  476. }
  477. qr = list_first_entry(&conn->immed_queue_list,
  478. struct iscsi_queue_req, qr_list);
  479. list_del(&qr->qr_list);
  480. if (qr->cmd)
  481. atomic_dec(&qr->cmd->immed_queue_count);
  482. spin_unlock_bh(&conn->immed_queue_lock);
  483. return qr;
  484. }
  485. static void iscsit_remove_cmd_from_immediate_queue(
  486. struct iscsi_cmd *cmd,
  487. struct iscsi_conn *conn)
  488. {
  489. struct iscsi_queue_req *qr, *qr_tmp;
  490. spin_lock_bh(&conn->immed_queue_lock);
  491. if (!atomic_read(&cmd->immed_queue_count)) {
  492. spin_unlock_bh(&conn->immed_queue_lock);
  493. return;
  494. }
  495. list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
  496. if (qr->cmd != cmd)
  497. continue;
  498. atomic_dec(&qr->cmd->immed_queue_count);
  499. list_del(&qr->qr_list);
  500. kmem_cache_free(lio_qr_cache, qr);
  501. }
  502. spin_unlock_bh(&conn->immed_queue_lock);
  503. if (atomic_read(&cmd->immed_queue_count)) {
  504. pr_err("ITT: 0x%08x immed_queue_count: %d\n",
  505. cmd->init_task_tag,
  506. atomic_read(&cmd->immed_queue_count));
  507. }
  508. }
  509. int iscsit_add_cmd_to_response_queue(
  510. struct iscsi_cmd *cmd,
  511. struct iscsi_conn *conn,
  512. u8 state)
  513. {
  514. struct iscsi_queue_req *qr;
  515. qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
  516. if (!qr) {
  517. pr_err("Unable to allocate memory for"
  518. " struct iscsi_queue_req\n");
  519. return -ENOMEM;
  520. }
  521. INIT_LIST_HEAD(&qr->qr_list);
  522. qr->cmd = cmd;
  523. qr->state = state;
  524. spin_lock_bh(&conn->response_queue_lock);
  525. list_add_tail(&qr->qr_list, &conn->response_queue_list);
  526. atomic_inc(&cmd->response_queue_count);
  527. spin_unlock_bh(&conn->response_queue_lock);
  528. wake_up(&conn->queues_wq);
  529. return 0;
  530. }
  531. struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsi_conn *conn)
  532. {
  533. struct iscsi_queue_req *qr;
  534. spin_lock_bh(&conn->response_queue_lock);
  535. if (list_empty(&conn->response_queue_list)) {
  536. spin_unlock_bh(&conn->response_queue_lock);
  537. return NULL;
  538. }
  539. qr = list_first_entry(&conn->response_queue_list,
  540. struct iscsi_queue_req, qr_list);
  541. list_del(&qr->qr_list);
  542. if (qr->cmd)
  543. atomic_dec(&qr->cmd->response_queue_count);
  544. spin_unlock_bh(&conn->response_queue_lock);
  545. return qr;
  546. }
  547. static void iscsit_remove_cmd_from_response_queue(
  548. struct iscsi_cmd *cmd,
  549. struct iscsi_conn *conn)
  550. {
  551. struct iscsi_queue_req *qr, *qr_tmp;
  552. spin_lock_bh(&conn->response_queue_lock);
  553. if (!atomic_read(&cmd->response_queue_count)) {
  554. spin_unlock_bh(&conn->response_queue_lock);
  555. return;
  556. }
  557. list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list,
  558. qr_list) {
  559. if (qr->cmd != cmd)
  560. continue;
  561. atomic_dec(&qr->cmd->response_queue_count);
  562. list_del(&qr->qr_list);
  563. kmem_cache_free(lio_qr_cache, qr);
  564. }
  565. spin_unlock_bh(&conn->response_queue_lock);
  566. if (atomic_read(&cmd->response_queue_count)) {
  567. pr_err("ITT: 0x%08x response_queue_count: %d\n",
  568. cmd->init_task_tag,
  569. atomic_read(&cmd->response_queue_count));
  570. }
  571. }
  572. bool iscsit_conn_all_queues_empty(struct iscsi_conn *conn)
  573. {
  574. bool empty;
  575. spin_lock_bh(&conn->immed_queue_lock);
  576. empty = list_empty(&conn->immed_queue_list);
  577. spin_unlock_bh(&conn->immed_queue_lock);
  578. if (!empty)
  579. return empty;
  580. spin_lock_bh(&conn->response_queue_lock);
  581. empty = list_empty(&conn->response_queue_list);
  582. spin_unlock_bh(&conn->response_queue_lock);
  583. return empty;
  584. }
  585. void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *conn)
  586. {
  587. struct iscsi_queue_req *qr, *qr_tmp;
  588. spin_lock_bh(&conn->immed_queue_lock);
  589. list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) {
  590. list_del(&qr->qr_list);
  591. if (qr->cmd)
  592. atomic_dec(&qr->cmd->immed_queue_count);
  593. kmem_cache_free(lio_qr_cache, qr);
  594. }
  595. spin_unlock_bh(&conn->immed_queue_lock);
  596. spin_lock_bh(&conn->response_queue_lock);
  597. list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list,
  598. qr_list) {
  599. list_del(&qr->qr_list);
  600. if (qr->cmd)
  601. atomic_dec(&qr->cmd->response_queue_count);
  602. kmem_cache_free(lio_qr_cache, qr);
  603. }
  604. spin_unlock_bh(&conn->response_queue_lock);
  605. }
  606. void iscsit_release_cmd(struct iscsi_cmd *cmd)
  607. {
  608. struct iscsi_session *sess;
  609. struct se_cmd *se_cmd = &cmd->se_cmd;
  610. WARN_ON(!list_empty(&cmd->i_conn_node));
  611. if (cmd->conn)
  612. sess = cmd->conn->sess;
  613. else
  614. sess = cmd->sess;
  615. BUG_ON(!sess || !sess->se_sess);
  616. kfree(cmd->buf_ptr);
  617. kfree(cmd->pdu_list);
  618. kfree(cmd->seq_list);
  619. kfree(cmd->tmr_req);
  620. kfree(cmd->overflow_buf);
  621. kfree(cmd->iov_data);
  622. kfree(cmd->text_in_ptr);
  623. target_free_tag(sess->se_sess, se_cmd);
  624. }
  625. EXPORT_SYMBOL(iscsit_release_cmd);
  626. void __iscsit_free_cmd(struct iscsi_cmd *cmd, bool check_queues)
  627. {
  628. struct iscsi_conn *conn = cmd->conn;
  629. WARN_ON(!list_empty(&cmd->i_conn_node));
  630. if (cmd->data_direction == DMA_TO_DEVICE) {
  631. iscsit_stop_dataout_timer(cmd);
  632. iscsit_free_r2ts_from_list(cmd);
  633. }
  634. if (cmd->data_direction == DMA_FROM_DEVICE)
  635. iscsit_free_all_datain_reqs(cmd);
  636. if (conn && check_queues) {
  637. iscsit_remove_cmd_from_immediate_queue(cmd, conn);
  638. iscsit_remove_cmd_from_response_queue(cmd, conn);
  639. }
  640. if (conn && conn->conn_transport->iscsit_unmap_cmd)
  641. conn->conn_transport->iscsit_unmap_cmd(conn, cmd);
  642. }
  643. void iscsit_free_cmd(struct iscsi_cmd *cmd, bool shutdown)
  644. {
  645. struct se_cmd *se_cmd = cmd->se_cmd.se_tfo ? &cmd->se_cmd : NULL;
  646. int rc;
  647. WARN_ON(!list_empty(&cmd->i_conn_node));
  648. __iscsit_free_cmd(cmd, shutdown);
  649. if (se_cmd) {
  650. rc = transport_generic_free_cmd(se_cmd, shutdown);
  651. if (!rc && shutdown && se_cmd->se_sess) {
  652. __iscsit_free_cmd(cmd, shutdown);
  653. target_put_sess_cmd(se_cmd);
  654. }
  655. } else {
  656. iscsit_release_cmd(cmd);
  657. }
  658. }
  659. EXPORT_SYMBOL(iscsit_free_cmd);
  660. int iscsit_check_session_usage_count(struct iscsi_session *sess)
  661. {
  662. spin_lock_bh(&sess->session_usage_lock);
  663. if (sess->session_usage_count != 0) {
  664. sess->session_waiting_on_uc = 1;
  665. spin_unlock_bh(&sess->session_usage_lock);
  666. if (in_interrupt())
  667. return 2;
  668. wait_for_completion(&sess->session_waiting_on_uc_comp);
  669. return 1;
  670. }
  671. spin_unlock_bh(&sess->session_usage_lock);
  672. return 0;
  673. }
  674. void iscsit_dec_session_usage_count(struct iscsi_session *sess)
  675. {
  676. spin_lock_bh(&sess->session_usage_lock);
  677. sess->session_usage_count--;
  678. if (!sess->session_usage_count && sess->session_waiting_on_uc)
  679. complete(&sess->session_waiting_on_uc_comp);
  680. spin_unlock_bh(&sess->session_usage_lock);
  681. }
  682. void iscsit_inc_session_usage_count(struct iscsi_session *sess)
  683. {
  684. spin_lock_bh(&sess->session_usage_lock);
  685. sess->session_usage_count++;
  686. spin_unlock_bh(&sess->session_usage_lock);
  687. }
  688. struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid)
  689. {
  690. struct iscsi_conn *conn;
  691. spin_lock_bh(&sess->conn_lock);
  692. list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
  693. if ((conn->cid == cid) &&
  694. (conn->conn_state == TARG_CONN_STATE_LOGGED_IN)) {
  695. iscsit_inc_conn_usage_count(conn);
  696. spin_unlock_bh(&sess->conn_lock);
  697. return conn;
  698. }
  699. }
  700. spin_unlock_bh(&sess->conn_lock);
  701. return NULL;
  702. }
  703. struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *sess, u16 cid)
  704. {
  705. struct iscsi_conn *conn;
  706. spin_lock_bh(&sess->conn_lock);
  707. list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
  708. if (conn->cid == cid) {
  709. iscsit_inc_conn_usage_count(conn);
  710. spin_lock(&conn->state_lock);
  711. atomic_set(&conn->connection_wait_rcfr, 1);
  712. spin_unlock(&conn->state_lock);
  713. spin_unlock_bh(&sess->conn_lock);
  714. return conn;
  715. }
  716. }
  717. spin_unlock_bh(&sess->conn_lock);
  718. return NULL;
  719. }
  720. void iscsit_check_conn_usage_count(struct iscsi_conn *conn)
  721. {
  722. spin_lock_bh(&conn->conn_usage_lock);
  723. if (conn->conn_usage_count != 0) {
  724. conn->conn_waiting_on_uc = 1;
  725. spin_unlock_bh(&conn->conn_usage_lock);
  726. wait_for_completion(&conn->conn_waiting_on_uc_comp);
  727. return;
  728. }
  729. spin_unlock_bh(&conn->conn_usage_lock);
  730. }
  731. void iscsit_dec_conn_usage_count(struct iscsi_conn *conn)
  732. {
  733. spin_lock_bh(&conn->conn_usage_lock);
  734. conn->conn_usage_count--;
  735. if (!conn->conn_usage_count && conn->conn_waiting_on_uc)
  736. complete(&conn->conn_waiting_on_uc_comp);
  737. spin_unlock_bh(&conn->conn_usage_lock);
  738. }
  739. void iscsit_inc_conn_usage_count(struct iscsi_conn *conn)
  740. {
  741. spin_lock_bh(&conn->conn_usage_lock);
  742. conn->conn_usage_count++;
  743. spin_unlock_bh(&conn->conn_usage_lock);
  744. }
  745. static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
  746. {
  747. u8 state;
  748. struct iscsi_cmd *cmd;
  749. cmd = iscsit_allocate_cmd(conn, TASK_RUNNING);
  750. if (!cmd)
  751. return -1;
  752. cmd->iscsi_opcode = ISCSI_OP_NOOP_IN;
  753. state = (want_response) ? ISTATE_SEND_NOPIN_WANT_RESPONSE :
  754. ISTATE_SEND_NOPIN_NO_RESPONSE;
  755. cmd->init_task_tag = RESERVED_ITT;
  756. cmd->targ_xfer_tag = (want_response) ?
  757. session_get_next_ttt(conn->sess) : 0xFFFFFFFF;
  758. spin_lock_bh(&conn->cmd_lock);
  759. list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
  760. spin_unlock_bh(&conn->cmd_lock);
  761. if (want_response)
  762. iscsit_start_nopin_response_timer(conn);
  763. iscsit_add_cmd_to_immediate_queue(cmd, conn, state);
  764. return 0;
  765. }
  766. void iscsit_handle_nopin_response_timeout(struct timer_list *t)
  767. {
  768. struct iscsi_conn *conn = from_timer(conn, t, nopin_response_timer);
  769. struct iscsi_session *sess = conn->sess;
  770. iscsit_inc_conn_usage_count(conn);
  771. spin_lock_bh(&conn->nopin_timer_lock);
  772. if (conn->nopin_response_timer_flags & ISCSI_TF_STOP) {
  773. spin_unlock_bh(&conn->nopin_timer_lock);
  774. iscsit_dec_conn_usage_count(conn);
  775. return;
  776. }
  777. pr_err("Did not receive response to NOPIN on CID: %hu, failing"
  778. " connection for I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
  779. conn->cid, sess->sess_ops->InitiatorName, sess->isid,
  780. sess->tpg->tpg_tiqn->tiqn, (u32)sess->tpg->tpgt);
  781. conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING;
  782. spin_unlock_bh(&conn->nopin_timer_lock);
  783. iscsit_fill_cxn_timeout_err_stats(sess);
  784. iscsit_cause_connection_reinstatement(conn, 0);
  785. iscsit_dec_conn_usage_count(conn);
  786. }
  787. void iscsit_mod_nopin_response_timer(struct iscsi_conn *conn)
  788. {
  789. struct iscsi_session *sess = conn->sess;
  790. struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
  791. spin_lock_bh(&conn->nopin_timer_lock);
  792. if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) {
  793. spin_unlock_bh(&conn->nopin_timer_lock);
  794. return;
  795. }
  796. mod_timer(&conn->nopin_response_timer,
  797. (get_jiffies_64() + na->nopin_response_timeout * HZ));
  798. spin_unlock_bh(&conn->nopin_timer_lock);
  799. }
  800. void iscsit_start_nopin_response_timer(struct iscsi_conn *conn)
  801. {
  802. struct iscsi_session *sess = conn->sess;
  803. struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
  804. spin_lock_bh(&conn->nopin_timer_lock);
  805. if (conn->nopin_response_timer_flags & ISCSI_TF_RUNNING) {
  806. spin_unlock_bh(&conn->nopin_timer_lock);
  807. return;
  808. }
  809. conn->nopin_response_timer_flags &= ~ISCSI_TF_STOP;
  810. conn->nopin_response_timer_flags |= ISCSI_TF_RUNNING;
  811. mod_timer(&conn->nopin_response_timer,
  812. jiffies + na->nopin_response_timeout * HZ);
  813. pr_debug("Started NOPIN Response Timer on CID: %d to %u"
  814. " seconds\n", conn->cid, na->nopin_response_timeout);
  815. spin_unlock_bh(&conn->nopin_timer_lock);
  816. }
  817. void iscsit_stop_nopin_response_timer(struct iscsi_conn *conn)
  818. {
  819. spin_lock_bh(&conn->nopin_timer_lock);
  820. if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) {
  821. spin_unlock_bh(&conn->nopin_timer_lock);
  822. return;
  823. }
  824. conn->nopin_response_timer_flags |= ISCSI_TF_STOP;
  825. spin_unlock_bh(&conn->nopin_timer_lock);
  826. del_timer_sync(&conn->nopin_response_timer);
  827. spin_lock_bh(&conn->nopin_timer_lock);
  828. conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING;
  829. spin_unlock_bh(&conn->nopin_timer_lock);
  830. }
  831. void iscsit_handle_nopin_timeout(struct timer_list *t)
  832. {
  833. struct iscsi_conn *conn = from_timer(conn, t, nopin_timer);
  834. iscsit_inc_conn_usage_count(conn);
  835. spin_lock_bh(&conn->nopin_timer_lock);
  836. if (conn->nopin_timer_flags & ISCSI_TF_STOP) {
  837. spin_unlock_bh(&conn->nopin_timer_lock);
  838. iscsit_dec_conn_usage_count(conn);
  839. return;
  840. }
  841. conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING;
  842. spin_unlock_bh(&conn->nopin_timer_lock);
  843. iscsit_add_nopin(conn, 1);
  844. iscsit_dec_conn_usage_count(conn);
  845. }
  846. void __iscsit_start_nopin_timer(struct iscsi_conn *conn)
  847. {
  848. struct iscsi_session *sess = conn->sess;
  849. struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
  850. lockdep_assert_held(&conn->nopin_timer_lock);
  851. /*
  852. * NOPIN timeout is disabled.
  853. */
  854. if (!na->nopin_timeout)
  855. return;
  856. if (conn->nopin_timer_flags & ISCSI_TF_RUNNING)
  857. return;
  858. conn->nopin_timer_flags &= ~ISCSI_TF_STOP;
  859. conn->nopin_timer_flags |= ISCSI_TF_RUNNING;
  860. mod_timer(&conn->nopin_timer, jiffies + na->nopin_timeout * HZ);
  861. pr_debug("Started NOPIN Timer on CID: %d at %u second"
  862. " interval\n", conn->cid, na->nopin_timeout);
  863. }
  864. void iscsit_start_nopin_timer(struct iscsi_conn *conn)
  865. {
  866. spin_lock_bh(&conn->nopin_timer_lock);
  867. __iscsit_start_nopin_timer(conn);
  868. spin_unlock_bh(&conn->nopin_timer_lock);
  869. }
  870. void iscsit_stop_nopin_timer(struct iscsi_conn *conn)
  871. {
  872. spin_lock_bh(&conn->nopin_timer_lock);
  873. if (!(conn->nopin_timer_flags & ISCSI_TF_RUNNING)) {
  874. spin_unlock_bh(&conn->nopin_timer_lock);
  875. return;
  876. }
  877. conn->nopin_timer_flags |= ISCSI_TF_STOP;
  878. spin_unlock_bh(&conn->nopin_timer_lock);
  879. del_timer_sync(&conn->nopin_timer);
  880. spin_lock_bh(&conn->nopin_timer_lock);
  881. conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING;
  882. spin_unlock_bh(&conn->nopin_timer_lock);
  883. }
  884. int iscsit_send_tx_data(
  885. struct iscsi_cmd *cmd,
  886. struct iscsi_conn *conn,
  887. int use_misc)
  888. {
  889. int tx_sent, tx_size;
  890. u32 iov_count;
  891. struct kvec *iov;
  892. send_data:
  893. tx_size = cmd->tx_size;
  894. if (!use_misc) {
  895. iov = &cmd->iov_data[0];
  896. iov_count = cmd->iov_data_count;
  897. } else {
  898. iov = &cmd->iov_misc[0];
  899. iov_count = cmd->iov_misc_count;
  900. }
  901. tx_sent = tx_data(conn, &iov[0], iov_count, tx_size);
  902. if (tx_size != tx_sent) {
  903. if (tx_sent == -EAGAIN) {
  904. pr_err("tx_data() returned -EAGAIN\n");
  905. goto send_data;
  906. } else
  907. return -1;
  908. }
  909. cmd->tx_size = 0;
  910. return 0;
  911. }
  912. int iscsit_fe_sendpage_sg(
  913. struct iscsi_cmd *cmd,
  914. struct iscsi_conn *conn)
  915. {
  916. struct scatterlist *sg = cmd->first_data_sg;
  917. struct kvec iov;
  918. u32 tx_hdr_size, data_len;
  919. u32 offset = cmd->first_data_sg_off;
  920. int tx_sent, iov_off;
  921. send_hdr:
  922. tx_hdr_size = ISCSI_HDR_LEN;
  923. if (conn->conn_ops->HeaderDigest)
  924. tx_hdr_size += ISCSI_CRC_LEN;
  925. iov.iov_base = cmd->pdu;
  926. iov.iov_len = tx_hdr_size;
  927. tx_sent = tx_data(conn, &iov, 1, tx_hdr_size);
  928. if (tx_hdr_size != tx_sent) {
  929. if (tx_sent == -EAGAIN) {
  930. pr_err("tx_data() returned -EAGAIN\n");
  931. goto send_hdr;
  932. }
  933. return -1;
  934. }
  935. data_len = cmd->tx_size - tx_hdr_size - cmd->padding;
  936. /*
  937. * Set iov_off used by padding and data digest tx_data() calls below
  938. * in order to determine proper offset into cmd->iov_data[]
  939. */
  940. if (conn->conn_ops->DataDigest) {
  941. data_len -= ISCSI_CRC_LEN;
  942. if (cmd->padding)
  943. iov_off = (cmd->iov_data_count - 2);
  944. else
  945. iov_off = (cmd->iov_data_count - 1);
  946. } else {
  947. iov_off = (cmd->iov_data_count - 1);
  948. }
  949. /*
  950. * Perform sendpage() for each page in the scatterlist
  951. */
  952. while (data_len) {
  953. u32 space = (sg->length - offset);
  954. u32 sub_len = min_t(u32, data_len, space);
  955. send_pg:
  956. tx_sent = conn->sock->ops->sendpage(conn->sock,
  957. sg_page(sg), sg->offset + offset, sub_len, 0);
  958. if (tx_sent != sub_len) {
  959. if (tx_sent == -EAGAIN) {
  960. pr_err("tcp_sendpage() returned"
  961. " -EAGAIN\n");
  962. goto send_pg;
  963. }
  964. pr_err("tcp_sendpage() failure: %d\n",
  965. tx_sent);
  966. return -1;
  967. }
  968. data_len -= sub_len;
  969. offset = 0;
  970. sg = sg_next(sg);
  971. }
  972. send_padding:
  973. if (cmd->padding) {
  974. struct kvec *iov_p = &cmd->iov_data[iov_off++];
  975. tx_sent = tx_data(conn, iov_p, 1, cmd->padding);
  976. if (cmd->padding != tx_sent) {
  977. if (tx_sent == -EAGAIN) {
  978. pr_err("tx_data() returned -EAGAIN\n");
  979. goto send_padding;
  980. }
  981. return -1;
  982. }
  983. }
  984. send_datacrc:
  985. if (conn->conn_ops->DataDigest) {
  986. struct kvec *iov_d = &cmd->iov_data[iov_off];
  987. tx_sent = tx_data(conn, iov_d, 1, ISCSI_CRC_LEN);
  988. if (ISCSI_CRC_LEN != tx_sent) {
  989. if (tx_sent == -EAGAIN) {
  990. pr_err("tx_data() returned -EAGAIN\n");
  991. goto send_datacrc;
  992. }
  993. return -1;
  994. }
  995. }
  996. return 0;
  997. }
  998. /*
  999. * This function is used for mainly sending a ISCSI_TARG_LOGIN_RSP PDU
  1000. * back to the Initiator when an expection condition occurs with the
  1001. * errors set in status_class and status_detail.
  1002. *
  1003. * Parameters: iSCSI Connection, Status Class, Status Detail.
  1004. * Returns: 0 on success, -1 on error.
  1005. */
  1006. int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_detail)
  1007. {
  1008. struct iscsi_login_rsp *hdr;
  1009. struct iscsi_login *login = conn->conn_login;
  1010. login->login_failed = 1;
  1011. iscsit_collect_login_stats(conn, status_class, status_detail);
  1012. memset(&login->rsp[0], 0, ISCSI_HDR_LEN);
  1013. hdr = (struct iscsi_login_rsp *)&login->rsp[0];
  1014. hdr->opcode = ISCSI_OP_LOGIN_RSP;
  1015. hdr->status_class = status_class;
  1016. hdr->status_detail = status_detail;
  1017. hdr->itt = conn->login_itt;
  1018. return conn->conn_transport->iscsit_put_login_tx(conn, login, 0);
  1019. }
  1020. void iscsit_print_session_params(struct iscsi_session *sess)
  1021. {
  1022. struct iscsi_conn *conn;
  1023. pr_debug("-----------------------------[Session Params for"
  1024. " SID: %u]-----------------------------\n", sess->sid);
  1025. spin_lock_bh(&sess->conn_lock);
  1026. list_for_each_entry(conn, &sess->sess_conn_list, conn_list)
  1027. iscsi_dump_conn_ops(conn->conn_ops);
  1028. spin_unlock_bh(&sess->conn_lock);
  1029. iscsi_dump_sess_ops(sess->sess_ops);
  1030. }
  1031. int rx_data(
  1032. struct iscsi_conn *conn,
  1033. struct kvec *iov,
  1034. int iov_count,
  1035. int data)
  1036. {
  1037. int rx_loop = 0, total_rx = 0;
  1038. struct msghdr msg;
  1039. if (!conn || !conn->sock || !conn->conn_ops)
  1040. return -1;
  1041. memset(&msg, 0, sizeof(struct msghdr));
  1042. iov_iter_kvec(&msg.msg_iter, READ, iov, iov_count, data);
  1043. while (msg_data_left(&msg)) {
  1044. rx_loop = sock_recvmsg(conn->sock, &msg, MSG_WAITALL);
  1045. if (rx_loop <= 0) {
  1046. pr_debug("rx_loop: %d total_rx: %d\n",
  1047. rx_loop, total_rx);
  1048. return rx_loop;
  1049. }
  1050. total_rx += rx_loop;
  1051. pr_debug("rx_loop: %d, total_rx: %d, data: %d\n",
  1052. rx_loop, total_rx, data);
  1053. }
  1054. return total_rx;
  1055. }
  1056. int tx_data(
  1057. struct iscsi_conn *conn,
  1058. struct kvec *iov,
  1059. int iov_count,
  1060. int data)
  1061. {
  1062. struct msghdr msg;
  1063. int total_tx = 0;
  1064. if (!conn || !conn->sock || !conn->conn_ops)
  1065. return -1;
  1066. if (data <= 0) {
  1067. pr_err("Data length is: %d\n", data);
  1068. return -1;
  1069. }
  1070. memset(&msg, 0, sizeof(struct msghdr));
  1071. iov_iter_kvec(&msg.msg_iter, WRITE, iov, iov_count, data);
  1072. while (msg_data_left(&msg)) {
  1073. int tx_loop = sock_sendmsg(conn->sock, &msg);
  1074. if (tx_loop <= 0) {
  1075. pr_debug("tx_loop: %d total_tx %d\n",
  1076. tx_loop, total_tx);
  1077. return tx_loop;
  1078. }
  1079. total_tx += tx_loop;
  1080. pr_debug("tx_loop: %d, total_tx: %d, data: %d\n",
  1081. tx_loop, total_tx, data);
  1082. }
  1083. return total_tx;
  1084. }
  1085. void iscsit_collect_login_stats(
  1086. struct iscsi_conn *conn,
  1087. u8 status_class,
  1088. u8 status_detail)
  1089. {
  1090. struct iscsi_param *intrname = NULL;
  1091. struct iscsi_tiqn *tiqn;
  1092. struct iscsi_login_stats *ls;
  1093. tiqn = iscsit_snmp_get_tiqn(conn);
  1094. if (!tiqn)
  1095. return;
  1096. ls = &tiqn->login_stats;
  1097. spin_lock(&ls->lock);
  1098. if (status_class == ISCSI_STATUS_CLS_SUCCESS)
  1099. ls->accepts++;
  1100. else if (status_class == ISCSI_STATUS_CLS_REDIRECT) {
  1101. ls->redirects++;
  1102. ls->last_fail_type = ISCSI_LOGIN_FAIL_REDIRECT;
  1103. } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
  1104. (status_detail == ISCSI_LOGIN_STATUS_AUTH_FAILED)) {
  1105. ls->authenticate_fails++;
  1106. ls->last_fail_type = ISCSI_LOGIN_FAIL_AUTHENTICATE;
  1107. } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
  1108. (status_detail == ISCSI_LOGIN_STATUS_TGT_FORBIDDEN)) {
  1109. ls->authorize_fails++;
  1110. ls->last_fail_type = ISCSI_LOGIN_FAIL_AUTHORIZE;
  1111. } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) &&
  1112. (status_detail == ISCSI_LOGIN_STATUS_INIT_ERR)) {
  1113. ls->negotiate_fails++;
  1114. ls->last_fail_type = ISCSI_LOGIN_FAIL_NEGOTIATE;
  1115. } else {
  1116. ls->other_fails++;
  1117. ls->last_fail_type = ISCSI_LOGIN_FAIL_OTHER;
  1118. }
  1119. /* Save initiator name, ip address and time, if it is a failed login */
  1120. if (status_class != ISCSI_STATUS_CLS_SUCCESS) {
  1121. if (conn->param_list)
  1122. intrname = iscsi_find_param_from_key(INITIATORNAME,
  1123. conn->param_list);
  1124. strlcpy(ls->last_intr_fail_name,
  1125. (intrname ? intrname->value : "Unknown"),
  1126. sizeof(ls->last_intr_fail_name));
  1127. ls->last_intr_fail_ip_family = conn->login_family;
  1128. ls->last_intr_fail_sockaddr = conn->login_sockaddr;
  1129. ls->last_fail_time = get_jiffies_64();
  1130. }
  1131. spin_unlock(&ls->lock);
  1132. }
  1133. struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsi_conn *conn)
  1134. {
  1135. struct iscsi_portal_group *tpg;
  1136. if (!conn)
  1137. return NULL;
  1138. tpg = conn->tpg;
  1139. if (!tpg)
  1140. return NULL;
  1141. if (!tpg->tpg_tiqn)
  1142. return NULL;
  1143. return tpg->tpg_tiqn;
  1144. }
  1145. void iscsit_fill_cxn_timeout_err_stats(struct iscsi_session *sess)
  1146. {
  1147. struct iscsi_portal_group *tpg = sess->tpg;
  1148. struct iscsi_tiqn *tiqn = tpg->tpg_tiqn;
  1149. if (!tiqn)
  1150. return;
  1151. spin_lock_bh(&tiqn->sess_err_stats.lock);
  1152. strlcpy(tiqn->sess_err_stats.last_sess_fail_rem_name,
  1153. sess->sess_ops->InitiatorName,
  1154. sizeof(tiqn->sess_err_stats.last_sess_fail_rem_name));
  1155. tiqn->sess_err_stats.last_sess_failure_type =
  1156. ISCSI_SESS_ERR_CXN_TIMEOUT;
  1157. tiqn->sess_err_stats.cxn_timeout_errors++;
  1158. atomic_long_inc(&sess->conn_timeout_errors);
  1159. spin_unlock_bh(&tiqn->sess_err_stats.lock);
  1160. }