iscsi_target_nego.c 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*******************************************************************************
  3. * This file contains main functions related to iSCSI Parameter negotiation.
  4. *
  5. * (c) Copyright 2007-2013 Datera, Inc.
  6. *
  7. * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
  8. *
  9. ******************************************************************************/
  10. #include <linux/ctype.h>
  11. #include <linux/kthread.h>
  12. #include <linux/slab.h>
  13. #include <linux/sched/signal.h>
  14. #include <net/sock.h>
  15. #include <scsi/iscsi_proto.h>
  16. #include <target/target_core_base.h>
  17. #include <target/target_core_fabric.h>
  18. #include <target/iscsi/iscsi_transport.h>
  19. #include <target/iscsi/iscsi_target_core.h>
  20. #include "iscsi_target_parameters.h"
  21. #include "iscsi_target_login.h"
  22. #include "iscsi_target_nego.h"
  23. #include "iscsi_target_tpg.h"
  24. #include "iscsi_target_util.h"
  25. #include "iscsi_target.h"
  26. #include "iscsi_target_auth.h"
  27. #define MAX_LOGIN_PDUS 7
  28. #define TEXT_LEN 4096
  29. void convert_null_to_semi(char *buf, int len)
  30. {
  31. int i;
  32. for (i = 0; i < len; i++)
  33. if (buf[i] == '\0')
  34. buf[i] = ';';
  35. }
  36. static int strlen_semi(char *buf)
  37. {
  38. int i = 0;
  39. while (buf[i] != '\0') {
  40. if (buf[i] == ';')
  41. return i;
  42. i++;
  43. }
  44. return -1;
  45. }
  46. int extract_param(
  47. const char *in_buf,
  48. const char *pattern,
  49. unsigned int max_length,
  50. char *out_buf,
  51. unsigned char *type)
  52. {
  53. char *ptr;
  54. int len;
  55. if (!in_buf || !pattern || !out_buf || !type)
  56. return -1;
  57. ptr = strstr(in_buf, pattern);
  58. if (!ptr)
  59. return -1;
  60. ptr = strstr(ptr, "=");
  61. if (!ptr)
  62. return -1;
  63. ptr += 1;
  64. if (*ptr == '0' && (*(ptr+1) == 'x' || *(ptr+1) == 'X')) {
  65. ptr += 2; /* skip 0x */
  66. *type = HEX;
  67. } else
  68. *type = DECIMAL;
  69. len = strlen_semi(ptr);
  70. if (len < 0)
  71. return -1;
  72. if (len >= max_length) {
  73. pr_err("Length of input: %d exceeds max_length:"
  74. " %d\n", len, max_length);
  75. return -1;
  76. }
  77. memcpy(out_buf, ptr, len);
  78. out_buf[len] = '\0';
  79. return 0;
  80. }
  81. static u32 iscsi_handle_authentication(
  82. struct iscsi_conn *conn,
  83. char *in_buf,
  84. char *out_buf,
  85. int in_length,
  86. int *out_length,
  87. unsigned char *authtype)
  88. {
  89. struct iscsi_session *sess = conn->sess;
  90. struct iscsi_node_auth *auth;
  91. struct iscsi_node_acl *iscsi_nacl;
  92. struct iscsi_portal_group *iscsi_tpg;
  93. struct se_node_acl *se_nacl;
  94. if (!sess->sess_ops->SessionType) {
  95. /*
  96. * For SessionType=Normal
  97. */
  98. se_nacl = conn->sess->se_sess->se_node_acl;
  99. if (!se_nacl) {
  100. pr_err("Unable to locate struct se_node_acl for"
  101. " CHAP auth\n");
  102. return -1;
  103. }
  104. iscsi_nacl = container_of(se_nacl, struct iscsi_node_acl,
  105. se_node_acl);
  106. if (!iscsi_nacl) {
  107. pr_err("Unable to locate struct iscsi_node_acl for"
  108. " CHAP auth\n");
  109. return -1;
  110. }
  111. if (se_nacl->dynamic_node_acl) {
  112. iscsi_tpg = container_of(se_nacl->se_tpg,
  113. struct iscsi_portal_group, tpg_se_tpg);
  114. auth = &iscsi_tpg->tpg_demo_auth;
  115. } else {
  116. iscsi_nacl = container_of(se_nacl, struct iscsi_node_acl,
  117. se_node_acl);
  118. auth = &iscsi_nacl->node_auth;
  119. }
  120. } else {
  121. /*
  122. * For SessionType=Discovery
  123. */
  124. auth = &iscsit_global->discovery_acl.node_auth;
  125. }
  126. if (strstr("CHAP", authtype))
  127. strcpy(conn->sess->auth_type, "CHAP");
  128. else
  129. strcpy(conn->sess->auth_type, NONE);
  130. if (strstr("None", authtype))
  131. return 1;
  132. else if (strstr("CHAP", authtype))
  133. return chap_main_loop(conn, auth, in_buf, out_buf,
  134. &in_length, out_length);
  135. /* SRP, SPKM1, SPKM2 and KRB5 are unsupported */
  136. return 2;
  137. }
  138. static void iscsi_remove_failed_auth_entry(struct iscsi_conn *conn)
  139. {
  140. kfree(conn->auth_protocol);
  141. }
  142. int iscsi_target_check_login_request(
  143. struct iscsi_conn *conn,
  144. struct iscsi_login *login)
  145. {
  146. int req_csg, req_nsg;
  147. u32 payload_length;
  148. struct iscsi_login_req *login_req;
  149. login_req = (struct iscsi_login_req *) login->req;
  150. payload_length = ntoh24(login_req->dlength);
  151. switch (login_req->opcode & ISCSI_OPCODE_MASK) {
  152. case ISCSI_OP_LOGIN:
  153. break;
  154. default:
  155. pr_err("Received unknown opcode 0x%02x.\n",
  156. login_req->opcode & ISCSI_OPCODE_MASK);
  157. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  158. ISCSI_LOGIN_STATUS_INIT_ERR);
  159. return -1;
  160. }
  161. if ((login_req->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
  162. (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) {
  163. pr_err("Login request has both ISCSI_FLAG_LOGIN_CONTINUE"
  164. " and ISCSI_FLAG_LOGIN_TRANSIT set, protocol error.\n");
  165. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  166. ISCSI_LOGIN_STATUS_INIT_ERR);
  167. return -1;
  168. }
  169. req_csg = ISCSI_LOGIN_CURRENT_STAGE(login_req->flags);
  170. req_nsg = ISCSI_LOGIN_NEXT_STAGE(login_req->flags);
  171. if (req_csg != login->current_stage) {
  172. pr_err("Initiator unexpectedly changed login stage"
  173. " from %d to %d, login failed.\n", login->current_stage,
  174. req_csg);
  175. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  176. ISCSI_LOGIN_STATUS_INIT_ERR);
  177. return -1;
  178. }
  179. if ((req_nsg == 2) || (req_csg >= 2) ||
  180. ((login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT) &&
  181. (req_nsg <= req_csg))) {
  182. pr_err("Illegal login_req->flags Combination, CSG: %d,"
  183. " NSG: %d, ISCSI_FLAG_LOGIN_TRANSIT: %d.\n", req_csg,
  184. req_nsg, (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT));
  185. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  186. ISCSI_LOGIN_STATUS_INIT_ERR);
  187. return -1;
  188. }
  189. if ((login_req->max_version != login->version_max) ||
  190. (login_req->min_version != login->version_min)) {
  191. pr_err("Login request changed Version Max/Nin"
  192. " unexpectedly to 0x%02x/0x%02x, protocol error\n",
  193. login_req->max_version, login_req->min_version);
  194. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  195. ISCSI_LOGIN_STATUS_INIT_ERR);
  196. return -1;
  197. }
  198. if (memcmp(login_req->isid, login->isid, 6) != 0) {
  199. pr_err("Login request changed ISID unexpectedly,"
  200. " protocol error.\n");
  201. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  202. ISCSI_LOGIN_STATUS_INIT_ERR);
  203. return -1;
  204. }
  205. if (login_req->itt != login->init_task_tag) {
  206. pr_err("Login request changed ITT unexpectedly to"
  207. " 0x%08x, protocol error.\n", login_req->itt);
  208. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  209. ISCSI_LOGIN_STATUS_INIT_ERR);
  210. return -1;
  211. }
  212. if (payload_length > MAX_KEY_VALUE_PAIRS) {
  213. pr_err("Login request payload exceeds default"
  214. " MaxRecvDataSegmentLength: %u, protocol error.\n",
  215. MAX_KEY_VALUE_PAIRS);
  216. return -1;
  217. }
  218. return 0;
  219. }
  220. EXPORT_SYMBOL(iscsi_target_check_login_request);
  221. static int iscsi_target_check_first_request(
  222. struct iscsi_conn *conn,
  223. struct iscsi_login *login)
  224. {
  225. struct iscsi_param *param = NULL;
  226. struct se_node_acl *se_nacl;
  227. login->first_request = 0;
  228. list_for_each_entry(param, &conn->param_list->param_list, p_list) {
  229. if (!strncmp(param->name, SESSIONTYPE, 11)) {
  230. if (!IS_PSTATE_ACCEPTOR(param)) {
  231. pr_err("SessionType key not received"
  232. " in first login request.\n");
  233. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  234. ISCSI_LOGIN_STATUS_MISSING_FIELDS);
  235. return -1;
  236. }
  237. if (!strncmp(param->value, DISCOVERY, 9))
  238. return 0;
  239. }
  240. if (!strncmp(param->name, INITIATORNAME, 13)) {
  241. if (!IS_PSTATE_ACCEPTOR(param)) {
  242. if (!login->leading_connection)
  243. continue;
  244. pr_err("InitiatorName key not received"
  245. " in first login request.\n");
  246. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  247. ISCSI_LOGIN_STATUS_MISSING_FIELDS);
  248. return -1;
  249. }
  250. /*
  251. * For non-leading connections, double check that the
  252. * received InitiatorName matches the existing session's
  253. * struct iscsi_node_acl.
  254. */
  255. if (!login->leading_connection) {
  256. se_nacl = conn->sess->se_sess->se_node_acl;
  257. if (!se_nacl) {
  258. pr_err("Unable to locate"
  259. " struct se_node_acl\n");
  260. iscsit_tx_login_rsp(conn,
  261. ISCSI_STATUS_CLS_INITIATOR_ERR,
  262. ISCSI_LOGIN_STATUS_TGT_NOT_FOUND);
  263. return -1;
  264. }
  265. if (strcmp(param->value,
  266. se_nacl->initiatorname)) {
  267. pr_err("Incorrect"
  268. " InitiatorName: %s for this"
  269. " iSCSI Initiator Node.\n",
  270. param->value);
  271. iscsit_tx_login_rsp(conn,
  272. ISCSI_STATUS_CLS_INITIATOR_ERR,
  273. ISCSI_LOGIN_STATUS_TGT_NOT_FOUND);
  274. return -1;
  275. }
  276. }
  277. }
  278. }
  279. return 0;
  280. }
  281. static int iscsi_target_do_tx_login_io(struct iscsi_conn *conn, struct iscsi_login *login)
  282. {
  283. u32 padding = 0;
  284. struct iscsi_login_rsp *login_rsp;
  285. login_rsp = (struct iscsi_login_rsp *) login->rsp;
  286. login_rsp->opcode = ISCSI_OP_LOGIN_RSP;
  287. hton24(login_rsp->dlength, login->rsp_length);
  288. memcpy(login_rsp->isid, login->isid, 6);
  289. login_rsp->tsih = cpu_to_be16(login->tsih);
  290. login_rsp->itt = login->init_task_tag;
  291. login_rsp->statsn = cpu_to_be32(conn->stat_sn++);
  292. login_rsp->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn);
  293. login_rsp->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
  294. pr_debug("Sending Login Response, Flags: 0x%02x, ITT: 0x%08x,"
  295. " ExpCmdSN; 0x%08x, MaxCmdSN: 0x%08x, StatSN: 0x%08x, Length:"
  296. " %u\n", login_rsp->flags, (__force u32)login_rsp->itt,
  297. ntohl(login_rsp->exp_cmdsn), ntohl(login_rsp->max_cmdsn),
  298. ntohl(login_rsp->statsn), login->rsp_length);
  299. padding = ((-login->rsp_length) & 3);
  300. /*
  301. * Before sending the last login response containing the transition
  302. * bit for full-feature-phase, go ahead and start up TX/RX threads
  303. * now to avoid potential resource allocation failures after the
  304. * final login response has been sent.
  305. */
  306. if (login->login_complete) {
  307. int rc = iscsit_start_kthreads(conn);
  308. if (rc) {
  309. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  310. ISCSI_LOGIN_STATUS_NO_RESOURCES);
  311. return -1;
  312. }
  313. }
  314. if (conn->conn_transport->iscsit_put_login_tx(conn, login,
  315. login->rsp_length + padding) < 0)
  316. goto err;
  317. login->rsp_length = 0;
  318. return 0;
  319. err:
  320. if (login->login_complete) {
  321. if (conn->rx_thread && conn->rx_thread_active) {
  322. send_sig(SIGINT, conn->rx_thread, 1);
  323. complete(&conn->rx_login_comp);
  324. kthread_stop(conn->rx_thread);
  325. }
  326. if (conn->tx_thread && conn->tx_thread_active) {
  327. send_sig(SIGINT, conn->tx_thread, 1);
  328. kthread_stop(conn->tx_thread);
  329. }
  330. spin_lock(&iscsit_global->ts_bitmap_lock);
  331. bitmap_release_region(iscsit_global->ts_bitmap, conn->bitmap_id,
  332. get_order(1));
  333. spin_unlock(&iscsit_global->ts_bitmap_lock);
  334. }
  335. return -1;
  336. }
  337. static void iscsi_target_sk_data_ready(struct sock *sk)
  338. {
  339. struct iscsi_conn *conn = sk->sk_user_data;
  340. bool rc;
  341. pr_debug("Entering iscsi_target_sk_data_ready: conn: %p\n", conn);
  342. write_lock_bh(&sk->sk_callback_lock);
  343. if (!sk->sk_user_data) {
  344. write_unlock_bh(&sk->sk_callback_lock);
  345. return;
  346. }
  347. if (!test_bit(LOGIN_FLAGS_READY, &conn->login_flags)) {
  348. write_unlock_bh(&sk->sk_callback_lock);
  349. pr_debug("Got LOGIN_FLAGS_READY=0, conn: %p >>>>\n", conn);
  350. return;
  351. }
  352. if (test_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags)) {
  353. write_unlock_bh(&sk->sk_callback_lock);
  354. pr_debug("Got LOGIN_FLAGS_CLOSED=1, conn: %p >>>>\n", conn);
  355. return;
  356. }
  357. if (test_and_set_bit(LOGIN_FLAGS_READ_ACTIVE, &conn->login_flags)) {
  358. write_unlock_bh(&sk->sk_callback_lock);
  359. pr_debug("Got LOGIN_FLAGS_READ_ACTIVE=1, conn: %p >>>>\n", conn);
  360. if (iscsi_target_sk_data_ready == conn->orig_data_ready)
  361. return;
  362. conn->orig_data_ready(sk);
  363. return;
  364. }
  365. rc = schedule_delayed_work(&conn->login_work, 0);
  366. if (!rc) {
  367. pr_debug("iscsi_target_sk_data_ready, schedule_delayed_work"
  368. " got false\n");
  369. }
  370. write_unlock_bh(&sk->sk_callback_lock);
  371. }
  372. static void iscsi_target_sk_state_change(struct sock *);
  373. static void iscsi_target_set_sock_callbacks(struct iscsi_conn *conn)
  374. {
  375. struct sock *sk;
  376. if (!conn->sock)
  377. return;
  378. sk = conn->sock->sk;
  379. pr_debug("Entering iscsi_target_set_sock_callbacks: conn: %p\n", conn);
  380. write_lock_bh(&sk->sk_callback_lock);
  381. sk->sk_user_data = conn;
  382. conn->orig_data_ready = sk->sk_data_ready;
  383. conn->orig_state_change = sk->sk_state_change;
  384. sk->sk_data_ready = iscsi_target_sk_data_ready;
  385. sk->sk_state_change = iscsi_target_sk_state_change;
  386. write_unlock_bh(&sk->sk_callback_lock);
  387. sk->sk_sndtimeo = TA_LOGIN_TIMEOUT * HZ;
  388. sk->sk_rcvtimeo = TA_LOGIN_TIMEOUT * HZ;
  389. }
  390. static void iscsi_target_restore_sock_callbacks(struct iscsi_conn *conn)
  391. {
  392. struct sock *sk;
  393. if (!conn->sock)
  394. return;
  395. sk = conn->sock->sk;
  396. pr_debug("Entering iscsi_target_restore_sock_callbacks: conn: %p\n", conn);
  397. write_lock_bh(&sk->sk_callback_lock);
  398. if (!sk->sk_user_data) {
  399. write_unlock_bh(&sk->sk_callback_lock);
  400. return;
  401. }
  402. sk->sk_user_data = NULL;
  403. sk->sk_data_ready = conn->orig_data_ready;
  404. sk->sk_state_change = conn->orig_state_change;
  405. write_unlock_bh(&sk->sk_callback_lock);
  406. sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
  407. sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  408. }
  409. static int iscsi_target_do_login(struct iscsi_conn *, struct iscsi_login *);
  410. static bool __iscsi_target_sk_check_close(struct sock *sk)
  411. {
  412. if (sk->sk_state == TCP_CLOSE_WAIT || sk->sk_state == TCP_CLOSE) {
  413. pr_debug("__iscsi_target_sk_check_close: TCP_CLOSE_WAIT|TCP_CLOSE,"
  414. "returning TRUE\n");
  415. return true;
  416. }
  417. return false;
  418. }
  419. static bool iscsi_target_sk_check_close(struct iscsi_conn *conn)
  420. {
  421. bool state = false;
  422. if (conn->sock) {
  423. struct sock *sk = conn->sock->sk;
  424. read_lock_bh(&sk->sk_callback_lock);
  425. state = (__iscsi_target_sk_check_close(sk) ||
  426. test_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags));
  427. read_unlock_bh(&sk->sk_callback_lock);
  428. }
  429. return state;
  430. }
  431. static bool iscsi_target_sk_check_flag(struct iscsi_conn *conn, unsigned int flag)
  432. {
  433. bool state = false;
  434. if (conn->sock) {
  435. struct sock *sk = conn->sock->sk;
  436. read_lock_bh(&sk->sk_callback_lock);
  437. state = test_bit(flag, &conn->login_flags);
  438. read_unlock_bh(&sk->sk_callback_lock);
  439. }
  440. return state;
  441. }
  442. static bool iscsi_target_sk_check_and_clear(struct iscsi_conn *conn, unsigned int flag)
  443. {
  444. bool state = false;
  445. if (conn->sock) {
  446. struct sock *sk = conn->sock->sk;
  447. write_lock_bh(&sk->sk_callback_lock);
  448. state = (__iscsi_target_sk_check_close(sk) ||
  449. test_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags));
  450. if (!state)
  451. clear_bit(flag, &conn->login_flags);
  452. write_unlock_bh(&sk->sk_callback_lock);
  453. }
  454. return state;
  455. }
  456. static void iscsi_target_login_drop(struct iscsi_conn *conn, struct iscsi_login *login)
  457. {
  458. bool zero_tsih = login->zero_tsih;
  459. iscsi_remove_failed_auth_entry(conn);
  460. iscsi_target_nego_release(conn);
  461. iscsi_target_login_sess_out(conn, zero_tsih, true);
  462. }
  463. struct conn_timeout {
  464. struct timer_list timer;
  465. struct iscsi_conn *conn;
  466. };
  467. static void iscsi_target_login_timeout(struct timer_list *t)
  468. {
  469. struct conn_timeout *timeout = from_timer(timeout, t, timer);
  470. struct iscsi_conn *conn = timeout->conn;
  471. pr_debug("Entering iscsi_target_login_timeout >>>>>>>>>>>>>>>>>>>\n");
  472. if (conn->login_kworker) {
  473. pr_debug("Sending SIGINT to conn->login_kworker %s/%d\n",
  474. conn->login_kworker->comm, conn->login_kworker->pid);
  475. send_sig(SIGINT, conn->login_kworker, 1);
  476. }
  477. }
  478. static void iscsi_target_do_login_rx(struct work_struct *work)
  479. {
  480. struct iscsi_conn *conn = container_of(work,
  481. struct iscsi_conn, login_work.work);
  482. struct iscsi_login *login = conn->login;
  483. struct iscsi_np *np = login->np;
  484. struct iscsi_portal_group *tpg = conn->tpg;
  485. struct iscsi_tpg_np *tpg_np = conn->tpg_np;
  486. struct conn_timeout timeout;
  487. int rc, zero_tsih = login->zero_tsih;
  488. bool state;
  489. pr_debug("entering iscsi_target_do_login_rx, conn: %p, %s:%d\n",
  490. conn, current->comm, current->pid);
  491. /*
  492. * If iscsi_target_do_login_rx() has been invoked by ->sk_data_ready()
  493. * before initial PDU processing in iscsi_target_start_negotiation()
  494. * has completed, go ahead and retry until it's cleared.
  495. *
  496. * Otherwise if the TCP connection drops while this is occuring,
  497. * iscsi_target_start_negotiation() will detect the failure, call
  498. * cancel_delayed_work_sync(&conn->login_work), and cleanup the
  499. * remaining iscsi connection resources from iscsi_np process context.
  500. */
  501. if (iscsi_target_sk_check_flag(conn, LOGIN_FLAGS_INITIAL_PDU)) {
  502. schedule_delayed_work(&conn->login_work, msecs_to_jiffies(10));
  503. return;
  504. }
  505. spin_lock(&tpg->tpg_state_lock);
  506. state = (tpg->tpg_state == TPG_STATE_ACTIVE);
  507. spin_unlock(&tpg->tpg_state_lock);
  508. if (!state) {
  509. pr_debug("iscsi_target_do_login_rx: tpg_state != TPG_STATE_ACTIVE\n");
  510. goto err;
  511. }
  512. if (iscsi_target_sk_check_close(conn)) {
  513. pr_debug("iscsi_target_do_login_rx, TCP state CLOSE\n");
  514. goto err;
  515. }
  516. conn->login_kworker = current;
  517. allow_signal(SIGINT);
  518. timeout.conn = conn;
  519. timer_setup_on_stack(&timeout.timer, iscsi_target_login_timeout, 0);
  520. mod_timer(&timeout.timer, jiffies + TA_LOGIN_TIMEOUT * HZ);
  521. pr_debug("Starting login timer for %s/%d\n", current->comm, current->pid);
  522. rc = conn->conn_transport->iscsit_get_login_rx(conn, login);
  523. del_timer_sync(&timeout.timer);
  524. destroy_timer_on_stack(&timeout.timer);
  525. flush_signals(current);
  526. conn->login_kworker = NULL;
  527. if (rc < 0)
  528. goto err;
  529. pr_debug("iscsi_target_do_login_rx after rx_login_io, %p, %s:%d\n",
  530. conn, current->comm, current->pid);
  531. /*
  532. * LOGIN_FLAGS_READ_ACTIVE is cleared so that sk_data_ready
  533. * could be triggered again after this.
  534. *
  535. * LOGIN_FLAGS_WRITE_ACTIVE is cleared after we successfully
  536. * process a login PDU, so that sk_state_chage can do login
  537. * cleanup as needed if the socket is closed. If a delayed work is
  538. * ongoing (LOGIN_FLAGS_WRITE_ACTIVE or LOGIN_FLAGS_READ_ACTIVE),
  539. * sk_state_change will leave the cleanup to the delayed work or
  540. * it will schedule a delayed work to do cleanup.
  541. */
  542. if (conn->sock) {
  543. struct sock *sk = conn->sock->sk;
  544. write_lock_bh(&sk->sk_callback_lock);
  545. if (!test_bit(LOGIN_FLAGS_INITIAL_PDU, &conn->login_flags)) {
  546. clear_bit(LOGIN_FLAGS_READ_ACTIVE, &conn->login_flags);
  547. set_bit(LOGIN_FLAGS_WRITE_ACTIVE, &conn->login_flags);
  548. }
  549. write_unlock_bh(&sk->sk_callback_lock);
  550. }
  551. rc = iscsi_target_do_login(conn, login);
  552. if (rc < 0) {
  553. goto err;
  554. } else if (!rc) {
  555. if (iscsi_target_sk_check_and_clear(conn,
  556. LOGIN_FLAGS_WRITE_ACTIVE))
  557. goto err;
  558. } else if (rc == 1) {
  559. cancel_delayed_work(&conn->login_work);
  560. iscsi_target_nego_release(conn);
  561. iscsi_post_login_handler(np, conn, zero_tsih);
  562. iscsit_deaccess_np(np, tpg, tpg_np);
  563. }
  564. return;
  565. err:
  566. iscsi_target_restore_sock_callbacks(conn);
  567. cancel_delayed_work(&conn->login_work);
  568. iscsi_target_login_drop(conn, login);
  569. iscsit_deaccess_np(np, tpg, tpg_np);
  570. }
  571. static void iscsi_target_sk_state_change(struct sock *sk)
  572. {
  573. struct iscsi_conn *conn;
  574. void (*orig_state_change)(struct sock *);
  575. bool state;
  576. pr_debug("Entering iscsi_target_sk_state_change\n");
  577. write_lock_bh(&sk->sk_callback_lock);
  578. conn = sk->sk_user_data;
  579. if (!conn) {
  580. write_unlock_bh(&sk->sk_callback_lock);
  581. return;
  582. }
  583. orig_state_change = conn->orig_state_change;
  584. if (!test_bit(LOGIN_FLAGS_READY, &conn->login_flags)) {
  585. pr_debug("Got LOGIN_FLAGS_READY=0 sk_state_change conn: %p\n",
  586. conn);
  587. write_unlock_bh(&sk->sk_callback_lock);
  588. orig_state_change(sk);
  589. return;
  590. }
  591. state = __iscsi_target_sk_check_close(sk);
  592. pr_debug("__iscsi_target_sk_close_change: state: %d\n", state);
  593. if (test_bit(LOGIN_FLAGS_READ_ACTIVE, &conn->login_flags) ||
  594. test_bit(LOGIN_FLAGS_WRITE_ACTIVE, &conn->login_flags)) {
  595. pr_debug("Got LOGIN_FLAGS_{READ|WRITE}_ACTIVE=1"
  596. " sk_state_change conn: %p\n", conn);
  597. if (state)
  598. set_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags);
  599. write_unlock_bh(&sk->sk_callback_lock);
  600. orig_state_change(sk);
  601. return;
  602. }
  603. if (test_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags)) {
  604. pr_debug("Got LOGIN_FLAGS_CLOSED=1 sk_state_change conn: %p\n",
  605. conn);
  606. write_unlock_bh(&sk->sk_callback_lock);
  607. orig_state_change(sk);
  608. return;
  609. }
  610. /*
  611. * If the TCP connection has dropped, go ahead and set LOGIN_FLAGS_CLOSED,
  612. * but only queue conn->login_work -> iscsi_target_do_login_rx()
  613. * processing if LOGIN_FLAGS_INITIAL_PDU has already been cleared.
  614. *
  615. * When iscsi_target_do_login_rx() runs, iscsi_target_sk_check_close()
  616. * will detect the dropped TCP connection from delayed workqueue context.
  617. *
  618. * If LOGIN_FLAGS_INITIAL_PDU is still set, which means the initial
  619. * iscsi_target_start_negotiation() is running, iscsi_target_do_login()
  620. * via iscsi_target_sk_check_close() or iscsi_target_start_negotiation()
  621. * via iscsi_target_sk_check_and_clear() is responsible for detecting the
  622. * dropped TCP connection in iscsi_np process context, and cleaning up
  623. * the remaining iscsi connection resources.
  624. */
  625. if (state) {
  626. pr_debug("iscsi_target_sk_state_change got failed state\n");
  627. set_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags);
  628. state = test_bit(LOGIN_FLAGS_INITIAL_PDU, &conn->login_flags);
  629. write_unlock_bh(&sk->sk_callback_lock);
  630. orig_state_change(sk);
  631. if (!state)
  632. schedule_delayed_work(&conn->login_work, 0);
  633. return;
  634. }
  635. write_unlock_bh(&sk->sk_callback_lock);
  636. orig_state_change(sk);
  637. }
  638. /*
  639. * NOTE: We check for existing sessions or connections AFTER the initiator
  640. * has been successfully authenticated in order to protect against faked
  641. * ISID/TSIH combinations.
  642. */
  643. static int iscsi_target_check_for_existing_instances(
  644. struct iscsi_conn *conn,
  645. struct iscsi_login *login)
  646. {
  647. if (login->checked_for_existing)
  648. return 0;
  649. login->checked_for_existing = 1;
  650. if (!login->tsih)
  651. return iscsi_check_for_session_reinstatement(conn);
  652. else
  653. return iscsi_login_post_auth_non_zero_tsih(conn, login->cid,
  654. login->initial_exp_statsn);
  655. }
  656. static int iscsi_target_do_authentication(
  657. struct iscsi_conn *conn,
  658. struct iscsi_login *login)
  659. {
  660. int authret;
  661. u32 payload_length;
  662. struct iscsi_param *param;
  663. struct iscsi_login_req *login_req;
  664. struct iscsi_login_rsp *login_rsp;
  665. login_req = (struct iscsi_login_req *) login->req;
  666. login_rsp = (struct iscsi_login_rsp *) login->rsp;
  667. payload_length = ntoh24(login_req->dlength);
  668. param = iscsi_find_param_from_key(AUTHMETHOD, conn->param_list);
  669. if (!param)
  670. return -1;
  671. authret = iscsi_handle_authentication(
  672. conn,
  673. login->req_buf,
  674. login->rsp_buf,
  675. payload_length,
  676. &login->rsp_length,
  677. param->value);
  678. switch (authret) {
  679. case 0:
  680. pr_debug("Received OK response"
  681. " from LIO Authentication, continuing.\n");
  682. break;
  683. case 1:
  684. pr_debug("iSCSI security negotiation"
  685. " completed successfully.\n");
  686. login->auth_complete = 1;
  687. if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE1) &&
  688. (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) {
  689. login_rsp->flags |= (ISCSI_FLAG_LOGIN_NEXT_STAGE1 |
  690. ISCSI_FLAG_LOGIN_TRANSIT);
  691. login->current_stage = 1;
  692. }
  693. return iscsi_target_check_for_existing_instances(
  694. conn, login);
  695. case 2:
  696. pr_err("Security negotiation"
  697. " failed.\n");
  698. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  699. ISCSI_LOGIN_STATUS_AUTH_FAILED);
  700. return -1;
  701. default:
  702. pr_err("Received unknown error %d from LIO"
  703. " Authentication\n", authret);
  704. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  705. ISCSI_LOGIN_STATUS_TARGET_ERROR);
  706. return -1;
  707. }
  708. return 0;
  709. }
  710. static int iscsi_target_handle_csg_zero(
  711. struct iscsi_conn *conn,
  712. struct iscsi_login *login)
  713. {
  714. int ret;
  715. u32 payload_length;
  716. struct iscsi_param *param;
  717. struct iscsi_login_req *login_req;
  718. struct iscsi_login_rsp *login_rsp;
  719. login_req = (struct iscsi_login_req *) login->req;
  720. login_rsp = (struct iscsi_login_rsp *) login->rsp;
  721. payload_length = ntoh24(login_req->dlength);
  722. param = iscsi_find_param_from_key(AUTHMETHOD, conn->param_list);
  723. if (!param)
  724. return -1;
  725. ret = iscsi_decode_text_input(
  726. PHASE_SECURITY|PHASE_DECLARATIVE,
  727. SENDER_INITIATOR|SENDER_RECEIVER,
  728. login->req_buf,
  729. payload_length,
  730. conn);
  731. if (ret < 0)
  732. return -1;
  733. if (ret > 0) {
  734. if (login->auth_complete) {
  735. pr_err("Initiator has already been"
  736. " successfully authenticated, but is still"
  737. " sending %s keys.\n", param->value);
  738. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  739. ISCSI_LOGIN_STATUS_INIT_ERR);
  740. return -1;
  741. }
  742. goto do_auth;
  743. } else if (!payload_length) {
  744. pr_err("Initiator sent zero length security payload,"
  745. " login failed\n");
  746. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  747. ISCSI_LOGIN_STATUS_AUTH_FAILED);
  748. return -1;
  749. }
  750. if (login->first_request)
  751. if (iscsi_target_check_first_request(conn, login) < 0)
  752. return -1;
  753. ret = iscsi_encode_text_output(
  754. PHASE_SECURITY|PHASE_DECLARATIVE,
  755. SENDER_TARGET,
  756. login->rsp_buf,
  757. &login->rsp_length,
  758. conn->param_list,
  759. conn->tpg->tpg_attrib.login_keys_workaround);
  760. if (ret < 0)
  761. return -1;
  762. if (!iscsi_check_negotiated_keys(conn->param_list)) {
  763. if (conn->tpg->tpg_attrib.authentication &&
  764. !strncmp(param->value, NONE, 4)) {
  765. pr_err("Initiator sent AuthMethod=None but"
  766. " Target is enforcing iSCSI Authentication,"
  767. " login failed.\n");
  768. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  769. ISCSI_LOGIN_STATUS_AUTH_FAILED);
  770. return -1;
  771. }
  772. if (conn->tpg->tpg_attrib.authentication &&
  773. !login->auth_complete)
  774. return 0;
  775. if (strncmp(param->value, NONE, 4) && !login->auth_complete)
  776. return 0;
  777. if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE1) &&
  778. (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) {
  779. login_rsp->flags |= ISCSI_FLAG_LOGIN_NEXT_STAGE1 |
  780. ISCSI_FLAG_LOGIN_TRANSIT;
  781. login->current_stage = 1;
  782. }
  783. }
  784. return 0;
  785. do_auth:
  786. return iscsi_target_do_authentication(conn, login);
  787. }
  788. static int iscsi_target_handle_csg_one(struct iscsi_conn *conn, struct iscsi_login *login)
  789. {
  790. int ret;
  791. u32 payload_length;
  792. struct iscsi_login_req *login_req;
  793. struct iscsi_login_rsp *login_rsp;
  794. login_req = (struct iscsi_login_req *) login->req;
  795. login_rsp = (struct iscsi_login_rsp *) login->rsp;
  796. payload_length = ntoh24(login_req->dlength);
  797. ret = iscsi_decode_text_input(
  798. PHASE_OPERATIONAL|PHASE_DECLARATIVE,
  799. SENDER_INITIATOR|SENDER_RECEIVER,
  800. login->req_buf,
  801. payload_length,
  802. conn);
  803. if (ret < 0) {
  804. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  805. ISCSI_LOGIN_STATUS_INIT_ERR);
  806. return -1;
  807. }
  808. if (login->first_request)
  809. if (iscsi_target_check_first_request(conn, login) < 0)
  810. return -1;
  811. if (iscsi_target_check_for_existing_instances(conn, login) < 0)
  812. return -1;
  813. ret = iscsi_encode_text_output(
  814. PHASE_OPERATIONAL|PHASE_DECLARATIVE,
  815. SENDER_TARGET,
  816. login->rsp_buf,
  817. &login->rsp_length,
  818. conn->param_list,
  819. conn->tpg->tpg_attrib.login_keys_workaround);
  820. if (ret < 0) {
  821. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  822. ISCSI_LOGIN_STATUS_INIT_ERR);
  823. return -1;
  824. }
  825. if (!login->auth_complete &&
  826. conn->tpg->tpg_attrib.authentication) {
  827. pr_err("Initiator is requesting CSG: 1, has not been"
  828. " successfully authenticated, and the Target is"
  829. " enforcing iSCSI Authentication, login failed.\n");
  830. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  831. ISCSI_LOGIN_STATUS_AUTH_FAILED);
  832. return -1;
  833. }
  834. if (!iscsi_check_negotiated_keys(conn->param_list))
  835. if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE3) &&
  836. (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT))
  837. login_rsp->flags |= ISCSI_FLAG_LOGIN_NEXT_STAGE3 |
  838. ISCSI_FLAG_LOGIN_TRANSIT;
  839. return 0;
  840. }
  841. static int iscsi_target_do_login(struct iscsi_conn *conn, struct iscsi_login *login)
  842. {
  843. int pdu_count = 0;
  844. struct iscsi_login_req *login_req;
  845. struct iscsi_login_rsp *login_rsp;
  846. login_req = (struct iscsi_login_req *) login->req;
  847. login_rsp = (struct iscsi_login_rsp *) login->rsp;
  848. while (1) {
  849. if (++pdu_count > MAX_LOGIN_PDUS) {
  850. pr_err("MAX_LOGIN_PDUS count reached.\n");
  851. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  852. ISCSI_LOGIN_STATUS_TARGET_ERROR);
  853. return -1;
  854. }
  855. switch (ISCSI_LOGIN_CURRENT_STAGE(login_req->flags)) {
  856. case 0:
  857. login_rsp->flags &= ~ISCSI_FLAG_LOGIN_CURRENT_STAGE_MASK;
  858. if (iscsi_target_handle_csg_zero(conn, login) < 0)
  859. return -1;
  860. break;
  861. case 1:
  862. login_rsp->flags |= ISCSI_FLAG_LOGIN_CURRENT_STAGE1;
  863. if (iscsi_target_handle_csg_one(conn, login) < 0)
  864. return -1;
  865. if (login_rsp->flags & ISCSI_FLAG_LOGIN_TRANSIT) {
  866. /*
  867. * Check to make sure the TCP connection has not
  868. * dropped asynchronously while session reinstatement
  869. * was occuring in this kthread context, before
  870. * transitioning to full feature phase operation.
  871. */
  872. if (iscsi_target_sk_check_close(conn))
  873. return -1;
  874. login->tsih = conn->sess->tsih;
  875. login->login_complete = 1;
  876. iscsi_target_restore_sock_callbacks(conn);
  877. if (iscsi_target_do_tx_login_io(conn,
  878. login) < 0)
  879. return -1;
  880. return 1;
  881. }
  882. break;
  883. default:
  884. pr_err("Illegal CSG: %d received from"
  885. " Initiator, protocol error.\n",
  886. ISCSI_LOGIN_CURRENT_STAGE(login_req->flags));
  887. break;
  888. }
  889. if (iscsi_target_do_tx_login_io(conn, login) < 0)
  890. return -1;
  891. if (login_rsp->flags & ISCSI_FLAG_LOGIN_TRANSIT) {
  892. login_rsp->flags &= ~ISCSI_FLAG_LOGIN_TRANSIT;
  893. login_rsp->flags &= ~ISCSI_FLAG_LOGIN_NEXT_STAGE_MASK;
  894. }
  895. break;
  896. }
  897. return 0;
  898. }
  899. static void iscsi_initiatorname_tolower(
  900. char *param_buf)
  901. {
  902. char *c;
  903. u32 iqn_size = strlen(param_buf), i;
  904. for (i = 0; i < iqn_size; i++) {
  905. c = &param_buf[i];
  906. if (!isupper(*c))
  907. continue;
  908. *c = tolower(*c);
  909. }
  910. }
  911. /*
  912. * Processes the first Login Request..
  913. */
  914. int iscsi_target_locate_portal(
  915. struct iscsi_np *np,
  916. struct iscsi_conn *conn,
  917. struct iscsi_login *login)
  918. {
  919. char *i_buf = NULL, *s_buf = NULL, *t_buf = NULL;
  920. char *tmpbuf, *start = NULL, *end = NULL, *key, *value;
  921. struct iscsi_session *sess = conn->sess;
  922. struct iscsi_tiqn *tiqn;
  923. struct iscsi_tpg_np *tpg_np = NULL;
  924. struct iscsi_login_req *login_req;
  925. struct se_node_acl *se_nacl;
  926. u32 payload_length, queue_depth = 0;
  927. int sessiontype = 0, ret = 0, tag_num, tag_size;
  928. INIT_DELAYED_WORK(&conn->login_work, iscsi_target_do_login_rx);
  929. iscsi_target_set_sock_callbacks(conn);
  930. login->np = np;
  931. login_req = (struct iscsi_login_req *) login->req;
  932. payload_length = ntoh24(login_req->dlength);
  933. tmpbuf = kzalloc(payload_length + 1, GFP_KERNEL);
  934. if (!tmpbuf) {
  935. pr_err("Unable to allocate memory for tmpbuf.\n");
  936. return -1;
  937. }
  938. memcpy(tmpbuf, login->req_buf, payload_length);
  939. tmpbuf[payload_length] = '\0';
  940. start = tmpbuf;
  941. end = (start + payload_length);
  942. /*
  943. * Locate the initial keys expected from the Initiator node in
  944. * the first login request in order to progress with the login phase.
  945. */
  946. while (start < end) {
  947. if (iscsi_extract_key_value(start, &key, &value) < 0) {
  948. ret = -1;
  949. goto out;
  950. }
  951. if (!strncmp(key, "InitiatorName", 13))
  952. i_buf = value;
  953. else if (!strncmp(key, "SessionType", 11))
  954. s_buf = value;
  955. else if (!strncmp(key, "TargetName", 10))
  956. t_buf = value;
  957. start += strlen(key) + strlen(value) + 2;
  958. }
  959. /*
  960. * See 5.3. Login Phase.
  961. */
  962. if (!i_buf) {
  963. pr_err("InitiatorName key not received"
  964. " in first login request.\n");
  965. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  966. ISCSI_LOGIN_STATUS_MISSING_FIELDS);
  967. ret = -1;
  968. goto out;
  969. }
  970. /*
  971. * Convert the incoming InitiatorName to lowercase following
  972. * RFC-3720 3.2.6.1. section c) that says that iSCSI IQNs
  973. * are NOT case sensitive.
  974. */
  975. iscsi_initiatorname_tolower(i_buf);
  976. if (!s_buf) {
  977. if (!login->leading_connection)
  978. goto get_target;
  979. pr_err("SessionType key not received"
  980. " in first login request.\n");
  981. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  982. ISCSI_LOGIN_STATUS_MISSING_FIELDS);
  983. ret = -1;
  984. goto out;
  985. }
  986. /*
  987. * Use default portal group for discovery sessions.
  988. */
  989. sessiontype = strncmp(s_buf, DISCOVERY, 9);
  990. if (!sessiontype) {
  991. conn->tpg = iscsit_global->discovery_tpg;
  992. if (!login->leading_connection)
  993. goto get_target;
  994. sess->sess_ops->SessionType = 1;
  995. /*
  996. * Setup crc32c modules from libcrypto
  997. */
  998. if (iscsi_login_setup_crypto(conn) < 0) {
  999. pr_err("iscsi_login_setup_crypto() failed\n");
  1000. ret = -1;
  1001. goto out;
  1002. }
  1003. /*
  1004. * Serialize access across the discovery struct iscsi_portal_group to
  1005. * process login attempt.
  1006. */
  1007. if (iscsit_access_np(np, conn->tpg) < 0) {
  1008. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  1009. ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
  1010. ret = -1;
  1011. goto out;
  1012. }
  1013. ret = 0;
  1014. goto alloc_tags;
  1015. }
  1016. get_target:
  1017. if (!t_buf) {
  1018. pr_err("TargetName key not received"
  1019. " in first login request while"
  1020. " SessionType=Normal.\n");
  1021. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  1022. ISCSI_LOGIN_STATUS_MISSING_FIELDS);
  1023. ret = -1;
  1024. goto out;
  1025. }
  1026. /*
  1027. * Locate Target IQN from Storage Node.
  1028. */
  1029. tiqn = iscsit_get_tiqn_for_login(t_buf);
  1030. if (!tiqn) {
  1031. pr_err("Unable to locate Target IQN: %s in"
  1032. " Storage Node\n", t_buf);
  1033. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  1034. ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
  1035. ret = -1;
  1036. goto out;
  1037. }
  1038. pr_debug("Located Storage Object: %s\n", tiqn->tiqn);
  1039. /*
  1040. * Locate Target Portal Group from Storage Node.
  1041. */
  1042. conn->tpg = iscsit_get_tpg_from_np(tiqn, np, &tpg_np);
  1043. if (!conn->tpg) {
  1044. pr_err("Unable to locate Target Portal Group"
  1045. " on %s\n", tiqn->tiqn);
  1046. iscsit_put_tiqn_for_login(tiqn);
  1047. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  1048. ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
  1049. ret = -1;
  1050. goto out;
  1051. }
  1052. conn->tpg_np = tpg_np;
  1053. pr_debug("Located Portal Group Object: %hu\n", conn->tpg->tpgt);
  1054. /*
  1055. * Setup crc32c modules from libcrypto
  1056. */
  1057. if (iscsi_login_setup_crypto(conn) < 0) {
  1058. pr_err("iscsi_login_setup_crypto() failed\n");
  1059. kref_put(&tpg_np->tpg_np_kref, iscsit_login_kref_put);
  1060. iscsit_put_tiqn_for_login(tiqn);
  1061. conn->tpg = NULL;
  1062. ret = -1;
  1063. goto out;
  1064. }
  1065. /*
  1066. * Serialize access across the struct iscsi_portal_group to
  1067. * process login attempt.
  1068. */
  1069. if (iscsit_access_np(np, conn->tpg) < 0) {
  1070. kref_put(&tpg_np->tpg_np_kref, iscsit_login_kref_put);
  1071. iscsit_put_tiqn_for_login(tiqn);
  1072. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  1073. ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
  1074. conn->tpg = NULL;
  1075. ret = -1;
  1076. goto out;
  1077. }
  1078. /*
  1079. * conn->sess->node_acl will be set when the referenced
  1080. * struct iscsi_session is located from received ISID+TSIH in
  1081. * iscsi_login_non_zero_tsih_s2().
  1082. */
  1083. if (!login->leading_connection) {
  1084. ret = 0;
  1085. goto out;
  1086. }
  1087. /*
  1088. * This value is required in iscsi_login_zero_tsih_s2()
  1089. */
  1090. sess->sess_ops->SessionType = 0;
  1091. /*
  1092. * Locate incoming Initiator IQN reference from Storage Node.
  1093. */
  1094. sess->se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
  1095. &conn->tpg->tpg_se_tpg, i_buf);
  1096. if (!sess->se_sess->se_node_acl) {
  1097. pr_err("iSCSI Initiator Node: %s is not authorized to"
  1098. " access iSCSI target portal group: %hu.\n",
  1099. i_buf, conn->tpg->tpgt);
  1100. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
  1101. ISCSI_LOGIN_STATUS_TGT_FORBIDDEN);
  1102. ret = -1;
  1103. goto out;
  1104. }
  1105. se_nacl = sess->se_sess->se_node_acl;
  1106. queue_depth = se_nacl->queue_depth;
  1107. /*
  1108. * Setup pre-allocated tags based upon allowed per NodeACL CmdSN
  1109. * depth for non immediate commands, plus extra tags for immediate
  1110. * commands.
  1111. *
  1112. * Also enforce a ISCSIT_MIN_TAGS to prevent unnecessary contention
  1113. * in per-cpu-ida tag allocation logic + small queue_depth.
  1114. */
  1115. alloc_tags:
  1116. tag_num = max_t(u32, ISCSIT_MIN_TAGS, queue_depth);
  1117. tag_num = (tag_num * 2) + ISCSIT_EXTRA_TAGS;
  1118. tag_size = sizeof(struct iscsi_cmd) + conn->conn_transport->priv_size;
  1119. ret = transport_alloc_session_tags(sess->se_sess, tag_num, tag_size);
  1120. if (ret < 0) {
  1121. iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
  1122. ISCSI_LOGIN_STATUS_NO_RESOURCES);
  1123. ret = -1;
  1124. }
  1125. out:
  1126. kfree(tmpbuf);
  1127. return ret;
  1128. }
  1129. int iscsi_target_start_negotiation(
  1130. struct iscsi_login *login,
  1131. struct iscsi_conn *conn)
  1132. {
  1133. int ret;
  1134. if (conn->sock) {
  1135. struct sock *sk = conn->sock->sk;
  1136. write_lock_bh(&sk->sk_callback_lock);
  1137. set_bit(LOGIN_FLAGS_READY, &conn->login_flags);
  1138. set_bit(LOGIN_FLAGS_INITIAL_PDU, &conn->login_flags);
  1139. write_unlock_bh(&sk->sk_callback_lock);
  1140. }
  1141. /*
  1142. * If iscsi_target_do_login returns zero to signal more PDU
  1143. * exchanges are required to complete the login, go ahead and
  1144. * clear LOGIN_FLAGS_INITIAL_PDU but only if the TCP connection
  1145. * is still active.
  1146. *
  1147. * Otherwise if TCP connection dropped asynchronously, go ahead
  1148. * and perform connection cleanup now.
  1149. */
  1150. ret = iscsi_target_do_login(conn, login);
  1151. if (!ret && iscsi_target_sk_check_and_clear(conn, LOGIN_FLAGS_INITIAL_PDU))
  1152. ret = -1;
  1153. if (ret < 0) {
  1154. cancel_delayed_work_sync(&conn->login_work);
  1155. iscsi_target_restore_sock_callbacks(conn);
  1156. iscsi_remove_failed_auth_entry(conn);
  1157. }
  1158. if (ret != 0)
  1159. iscsi_target_nego_release(conn);
  1160. return ret;
  1161. }
  1162. void iscsi_target_nego_release(struct iscsi_conn *conn)
  1163. {
  1164. struct iscsi_login *login = conn->conn_login;
  1165. if (!login)
  1166. return;
  1167. kfree(login->req_buf);
  1168. kfree(login->rsp_buf);
  1169. kfree(login);
  1170. conn->conn_login = NULL;
  1171. }