?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.4.102
[linux/fpc-iii.git] / drivers / target / iscsi / iscsi_target_login.c
blobbc7d08fc8bbd86ee0719bf90b85fe30c62913bbb
1 /*******************************************************************************
2 * This file contains the login functions used by the iSCSI Target driver.
3 *
4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
5 *
6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
7 *
8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 ******************************************************************************/
20
21 #include <linux/string.h>
22 #include <linux/kthread.h>
23 #include <linux/crypto.h>
24 #include <linux/idr.h>
25 #include <scsi/iscsi_proto.h>
26 #include <target/target_core_base.h>
27 #include <target/target_core_fabric.h>
28
29 #include "iscsi_target_core.h"
30 #include "iscsi_target_tq.h"
31 #include "iscsi_target_device.h"
32 #include "iscsi_target_nego.h"
33 #include "iscsi_target_erl0.h"
34 #include "iscsi_target_erl2.h"
35 #include "iscsi_target_login.h"
36 #include "iscsi_target_stat.h"
37 #include "iscsi_target_tpg.h"
38 #include "iscsi_target_util.h"
39 #include "iscsi_target.h"
40 #include "iscsi_target_parameters.h"
41
42 extern struct idr sess_idr;
43 extern struct mutex auth_id_lock;
44 extern spinlock_t sess_idr_lock;
45
46 static int iscsi_login_init_conn(struct iscsi_conn *conn)
47 {
48 init_waitqueue_head(&conn->queues_wq);
49 INIT_LIST_HEAD(&conn->conn_list);
50 INIT_LIST_HEAD(&conn->conn_cmd_list);
51 INIT_LIST_HEAD(&conn->immed_queue_list);
52 INIT_LIST_HEAD(&conn->response_queue_list);
53 init_completion(&conn->conn_post_wait_comp);
54 init_completion(&conn->conn_wait_comp);
55 init_completion(&conn->conn_wait_rcfr_comp);
56 init_completion(&conn->conn_waiting_on_uc_comp);
57 init_completion(&conn->conn_logout_comp);
58 init_completion(&conn->rx_half_close_comp);
59 init_completion(&conn->tx_half_close_comp);
60 spin_lock_init(&conn->cmd_lock);
61 spin_lock_init(&conn->conn_usage_lock);
62 spin_lock_init(&conn->immed_queue_lock);
63 spin_lock_init(&conn->nopin_timer_lock);
64 spin_lock_init(&conn->response_queue_lock);
65 spin_lock_init(&conn->state_lock);
66
67 if (!zalloc_cpumask_var(&conn->conn_cpumask, GFP_KERNEL)) {
68 pr_err("Unable to allocate conn->conn_cpumask\n");
69 return -ENOMEM;
70 }
71
72 return 0;
73 }
74
75 /*
76 * Used by iscsi_target_nego.c:iscsi_target_locate_portal() to setup
77 * per struct iscsi_conn libcrypto contexts for crc32c and crc32-intel
78 */
79 int iscsi_login_setup_crypto(struct iscsi_conn *conn)
80 {
81 /*
82 * Setup slicing by CRC32C algorithm for RX and TX libcrypto contexts
83 * which will default to crc32c_intel.ko for cpu_has_xmm4_2, or fallback
84 * to software 1x8 byte slicing from crc32c.ko
85 */
86 conn->conn_rx_hash.flags = 0;
87 conn->conn_rx_hash.tfm = crypto_alloc_hash("crc32c", 0,
88 CRYPTO_ALG_ASYNC);
89 if (IS_ERR(conn->conn_rx_hash.tfm)) {
90 pr_err("crypto_alloc_hash() failed for conn_rx_tfm\n");
91 return -ENOMEM;
92 }
93
94 conn->conn_tx_hash.flags = 0;
95 conn->conn_tx_hash.tfm = crypto_alloc_hash("crc32c", 0,
96 CRYPTO_ALG_ASYNC);
97 if (IS_ERR(conn->conn_tx_hash.tfm)) {
98 pr_err("crypto_alloc_hash() failed for conn_tx_tfm\n");
99 crypto_free_hash(conn->conn_rx_hash.tfm);
100 return -ENOMEM;
101 }
102
103 return 0;
104 }
105
106 static int iscsi_login_check_initiator_version(
107 struct iscsi_conn *conn,
108 u8 version_max,
109 u8 version_min)
110 {
111 if ((version_max != 0x00) || (version_min != 0x00)) {
112 pr_err("Unsupported iSCSI IETF Pre-RFC Revision,"
113 " version Min/Max 0x%02x/0x%02x, rejecting login.\n",
114 version_min, version_max);
115 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
116 ISCSI_LOGIN_STATUS_NO_VERSION);
117 return -1;
118 }
119
120 return 0;
121 }
122
123 int iscsi_check_for_session_reinstatement(struct iscsi_conn *conn)
124 {
125 int sessiontype;
126 struct iscsi_param *initiatorname_param = NULL, *sessiontype_param = NULL;
127 struct iscsi_portal_group *tpg = conn->tpg;
128 struct iscsi_session *sess = NULL, *sess_p = NULL;
129 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
130 struct se_session *se_sess, *se_sess_tmp;
131
132 initiatorname_param = iscsi_find_param_from_key(
133 INITIATORNAME, conn->param_list);
134 sessiontype_param = iscsi_find_param_from_key(
135 SESSIONTYPE, conn->param_list);
136 if (!initiatorname_param || !sessiontype_param) {
137 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
138 ISCSI_LOGIN_STATUS_MISSING_FIELDS);
139 return -1;
140 }
141
142 sessiontype = (strncmp(sessiontype_param->value, NORMAL, 6)) ? 1 : 0;
143
144 spin_lock_bh(&se_tpg->session_lock);
145 list_for_each_entry_safe(se_sess, se_sess_tmp, &se_tpg->tpg_sess_list,
146 sess_list) {
147
148 sess_p = se_sess->fabric_sess_ptr;
149 spin_lock(&sess_p->conn_lock);
150 if (atomic_read(&sess_p->session_fall_back_to_erl0) ||
151 atomic_read(&sess_p->session_logout) ||
152 (sess_p->time2retain_timer_flags & ISCSI_TF_EXPIRED)) {
153 spin_unlock(&sess_p->conn_lock);
154 continue;
155 }
156 if (!memcmp(sess_p->isid, conn->sess->isid, 6) &&
157 (!strcmp(sess_p->sess_ops->InitiatorName,
158 initiatorname_param->value) &&
159 (sess_p->sess_ops->SessionType == sessiontype))) {
160 atomic_set(&sess_p->session_reinstatement, 1);
161 spin_unlock(&sess_p->conn_lock);
162 iscsit_inc_session_usage_count(sess_p);
163 iscsit_stop_time2retain_timer(sess_p);
164 sess = sess_p;
165 break;
166 }
167 spin_unlock(&sess_p->conn_lock);
168 }
169 spin_unlock_bh(&se_tpg->session_lock);
170 /*
171 * If the Time2Retain handler has expired, the session is already gone.
172 */
173 if (!sess)
174 return 0;
175
176 pr_debug("%s iSCSI Session SID %u is still active for %s,"
177 " preforming session reinstatement.\n", (sessiontype) ?
178 "Discovery" : "Normal", sess->sid,
179 sess->sess_ops->InitiatorName);
180
181 spin_lock_bh(&sess->conn_lock);
182 if (sess->session_state == TARG_SESS_STATE_FAILED) {
183 spin_unlock_bh(&sess->conn_lock);
184 iscsit_dec_session_usage_count(sess);
185 target_put_session(sess->se_sess);
186 return 0;
187 }
188 spin_unlock_bh(&sess->conn_lock);
189
190 iscsit_stop_session(sess, 1, 1);
191 iscsit_dec_session_usage_count(sess);
192
193 target_put_session(sess->se_sess);
194 return 0;
195 }
196
197 static void iscsi_login_set_conn_values(
198 struct iscsi_session *sess,
199 struct iscsi_conn *conn,
200 u16 cid)
201 {
202 conn->sess = sess;
203 conn->cid = cid;
204 /*
205 * Generate a random Status sequence number (statsn) for the new
206 * iSCSI connection.
207 */
208 get_random_bytes(&conn->stat_sn, sizeof(u32));
209
210 mutex_lock(&auth_id_lock);
211 conn->auth_id = iscsit_global->auth_id++;
212 mutex_unlock(&auth_id_lock);
213 }
214
215 /*
216 * This is the leading connection of a new session,
217 * or session reinstatement.
218 */
219 static int iscsi_login_zero_tsih_s1(
220 struct iscsi_conn *conn,
221 unsigned char *buf)
222 {
223 struct iscsi_session *sess = NULL;
224 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf;
225
226 sess = kzalloc(sizeof(struct iscsi_session), GFP_KERNEL);
227 if (!sess) {
228 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
229 ISCSI_LOGIN_STATUS_NO_RESOURCES);
230 pr_err("Could not allocate memory for session\n");
231 return -ENOMEM;
232 }
233
234 iscsi_login_set_conn_values(sess, conn, pdu->cid);
235 sess->init_task_tag = pdu->itt;
236 memcpy(&sess->isid, pdu->isid, 6);
237 sess->exp_cmd_sn = pdu->cmdsn;
238 INIT_LIST_HEAD(&sess->sess_conn_list);
239 INIT_LIST_HEAD(&sess->sess_ooo_cmdsn_list);
240 INIT_LIST_HEAD(&sess->cr_active_list);
241 INIT_LIST_HEAD(&sess->cr_inactive_list);
242 init_completion(&sess->async_msg_comp);
243 init_completion(&sess->reinstatement_comp);
244 init_completion(&sess->session_wait_comp);
245 init_completion(&sess->session_waiting_on_uc_comp);
246 mutex_init(&sess->cmdsn_mutex);
247 spin_lock_init(&sess->conn_lock);
248 spin_lock_init(&sess->cr_a_lock);
249 spin_lock_init(&sess->cr_i_lock);
250 spin_lock_init(&sess->session_usage_lock);
251 spin_lock_init(&sess->ttt_lock);
252
253 if (!idr_pre_get(&sess_idr, GFP_KERNEL)) {
254 pr_err("idr_pre_get() for sess_idr failed\n");
255 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
256 ISCSI_LOGIN_STATUS_NO_RESOURCES);
257 kfree(sess);
258 return -ENOMEM;
259 }
260 spin_lock(&sess_idr_lock);
261 idr_get_new(&sess_idr, NULL, &sess->session_index);
262 spin_unlock(&sess_idr_lock);
263
264 sess->creation_time = get_jiffies_64();
265 spin_lock_init(&sess->session_stats_lock);
266 /*
267 * The FFP CmdSN window values will be allocated from the TPG's
268 * Initiator Node's ACL once the login has been successfully completed.
269 */
270 sess->max_cmd_sn = pdu->cmdsn;
271
272 sess->sess_ops = kzalloc(sizeof(struct iscsi_sess_ops), GFP_KERNEL);
273 if (!sess->sess_ops) {
274 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
275 ISCSI_LOGIN_STATUS_NO_RESOURCES);
276 pr_err("Unable to allocate memory for"
277 " struct iscsi_sess_ops.\n");
278 kfree(sess);
279 return -ENOMEM;
280 }
281
282 sess->se_sess = transport_init_session();
283 if (IS_ERR(sess->se_sess)) {
284 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
285 ISCSI_LOGIN_STATUS_NO_RESOURCES);
286 kfree(sess);
287 return -ENOMEM;
288 }
289
290 return 0;
291 }
292
293 static int iscsi_login_zero_tsih_s2(
294 struct iscsi_conn *conn)
295 {
296 struct iscsi_node_attrib *na;
297 struct iscsi_session *sess = conn->sess;
298 unsigned char buf[32];
299
300 sess->tpg = conn->tpg;
301
302 /*
303 * Assign a new TPG Session Handle. Note this is protected with
304 * struct iscsi_portal_group->np_login_sem from iscsit_access_np().
305 */
306 sess->tsih = ++ISCSI_TPG_S(sess)->ntsih;
307 if (!sess->tsih)
308 sess->tsih = ++ISCSI_TPG_S(sess)->ntsih;
309
310 /*
311 * Create the default params from user defined values..
312 */
313 if (iscsi_copy_param_list(&conn->param_list,
314 ISCSI_TPG_C(conn)->param_list, 1) < 0) {
315 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
316 ISCSI_LOGIN_STATUS_NO_RESOURCES);
317 return -1;
318 }
319
320 iscsi_set_keys_to_negotiate(0, conn->param_list);
321
322 if (sess->sess_ops->SessionType)
323 return iscsi_set_keys_irrelevant_for_discovery(
324 conn->param_list);
325
326 na = iscsit_tpg_get_node_attrib(sess);
327
328 /*
329 * Need to send TargetPortalGroupTag back in first login response
330 * on any iSCSI connection where the Initiator provides TargetName.
331 * See 5.3.1. Login Phase Start
332 *
333 * In our case, we have already located the struct iscsi_tiqn at this point.
334 */
335 memset(buf, 0, 32);
336 sprintf(buf, "TargetPortalGroupTag=%hu", ISCSI_TPG_S(sess)->tpgt);
337 if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) {
338 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
339 ISCSI_LOGIN_STATUS_NO_RESOURCES);
340 return -1;
341 }
342
343 /*
344 * Workaround for Initiators that have broken connection recovery logic.
345 *
346 * "We would really like to get rid of this." Linux-iSCSI.org team
347 */
348 memset(buf, 0, 32);
349 sprintf(buf, "ErrorRecoveryLevel=%d", na->default_erl);
350 if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) {
351 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
352 ISCSI_LOGIN_STATUS_NO_RESOURCES);
353 return -1;
354 }
355
356 if (iscsi_login_disable_FIM_keys(conn->param_list, conn) < 0)
357 return -1;
358
359 return 0;
360 }
361
362 /*
363 * Remove PSTATE_NEGOTIATE for the four FIM related keys.
364 * The Initiator node will be able to enable FIM by proposing them itself.
365 */
366 int iscsi_login_disable_FIM_keys(
367 struct iscsi_param_list *param_list,
368 struct iscsi_conn *conn)
369 {
370 struct iscsi_param *param;
371
372 param = iscsi_find_param_from_key("OFMarker", param_list);
373 if (!param) {
374 pr_err("iscsi_find_param_from_key() for"
375 " OFMarker failed\n");
376 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
377 ISCSI_LOGIN_STATUS_NO_RESOURCES);
378 return -1;
379 }
380 param->state &= ~PSTATE_NEGOTIATE;
381
382 param = iscsi_find_param_from_key("OFMarkInt", param_list);
383 if (!param) {
384 pr_err("iscsi_find_param_from_key() for"
385 " IFMarker failed\n");
386 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
387 ISCSI_LOGIN_STATUS_NO_RESOURCES);
388 return -1;
389 }
390 param->state &= ~PSTATE_NEGOTIATE;
391
392 param = iscsi_find_param_from_key("IFMarker", param_list);
393 if (!param) {
394 pr_err("iscsi_find_param_from_key() for"
395 " IFMarker failed\n");
396 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
397 ISCSI_LOGIN_STATUS_NO_RESOURCES);
398 return -1;
399 }
400 param->state &= ~PSTATE_NEGOTIATE;
401
402 param = iscsi_find_param_from_key("IFMarkInt", param_list);
403 if (!param) {
404 pr_err("iscsi_find_param_from_key() for"
405 " IFMarker failed\n");
406 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
407 ISCSI_LOGIN_STATUS_NO_RESOURCES);
408 return -1;
409 }
410 param->state &= ~PSTATE_NEGOTIATE;
411
412 return 0;
413 }
414
415 static int iscsi_login_non_zero_tsih_s1(
416 struct iscsi_conn *conn,
417 unsigned char *buf)
418 {
419 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf;
420
421 iscsi_login_set_conn_values(NULL, conn, pdu->cid);
422 return 0;
423 }
424
425 /*
426 * Add a new connection to an existing session.
427 */
428 static int iscsi_login_non_zero_tsih_s2(
429 struct iscsi_conn *conn,
430 unsigned char *buf)
431 {
432 struct iscsi_portal_group *tpg = conn->tpg;
433 struct iscsi_session *sess = NULL, *sess_p = NULL;
434 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
435 struct se_session *se_sess, *se_sess_tmp;
436 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf;
437
438 spin_lock_bh(&se_tpg->session_lock);
439 list_for_each_entry_safe(se_sess, se_sess_tmp, &se_tpg->tpg_sess_list,
440 sess_list) {
441
442 sess_p = (struct iscsi_session *)se_sess->fabric_sess_ptr;
443 if (atomic_read(&sess_p->session_fall_back_to_erl0) ||
444 atomic_read(&sess_p->session_logout) ||
445 (sess_p->time2retain_timer_flags & ISCSI_TF_EXPIRED))
446 continue;
447 if (!memcmp(sess_p->isid, pdu->isid, 6) &&
448 (sess_p->tsih == pdu->tsih)) {
449 iscsit_inc_session_usage_count(sess_p);
450 iscsit_stop_time2retain_timer(sess_p);
451 sess = sess_p;
452 break;
453 }
454 }
455 spin_unlock_bh(&se_tpg->session_lock);
456
457 /*
458 * If the Time2Retain handler has expired, the session is already gone.
459 */
460 if (!sess) {
461 pr_err("Initiator attempting to add a connection to"
462 " a non-existent session, rejecting iSCSI Login.\n");
463 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
464 ISCSI_LOGIN_STATUS_NO_SESSION);
465 return -1;
466 }
467
468 /*
469 * Stop the Time2Retain timer if this is a failed session, we restart
470 * the timer if the login is not successful.
471 */
472 spin_lock_bh(&sess->conn_lock);
473 if (sess->session_state == TARG_SESS_STATE_FAILED)
474 atomic_set(&sess->session_continuation, 1);
475 spin_unlock_bh(&sess->conn_lock);
476
477 iscsi_login_set_conn_values(sess, conn, pdu->cid);
478
479 if (iscsi_copy_param_list(&conn->param_list,
480 ISCSI_TPG_C(conn)->param_list, 0) < 0) {
481 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
482 ISCSI_LOGIN_STATUS_NO_RESOURCES);
483 return -1;
484 }
485
486 iscsi_set_keys_to_negotiate(0, conn->param_list);
487 /*
488 * Need to send TargetPortalGroupTag back in first login response
489 * on any iSCSI connection where the Initiator provides TargetName.
490 * See 5.3.1. Login Phase Start
491 *
492 * In our case, we have already located the struct iscsi_tiqn at this point.
493 */
494 memset(buf, 0, 32);
495 sprintf(buf, "TargetPortalGroupTag=%hu", ISCSI_TPG_S(sess)->tpgt);
496 if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) {
497 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
498 ISCSI_LOGIN_STATUS_NO_RESOURCES);
499 return -1;
500 }
501
502 return iscsi_login_disable_FIM_keys(conn->param_list, conn);
503 }
504
505 int iscsi_login_post_auth_non_zero_tsih(
506 struct iscsi_conn *conn,
507 u16 cid,
508 u32 exp_statsn)
509 {
510 struct iscsi_conn *conn_ptr = NULL;
511 struct iscsi_conn_recovery *cr = NULL;
512 struct iscsi_session *sess = conn->sess;
513
514 /*
515 * By following item 5 in the login table, if we have found
516 * an existing ISID and a valid/existing TSIH and an existing
517 * CID we do connection reinstatement. Currently we dont not
518 * support it so we send back an non-zero status class to the
519 * initiator and release the new connection.
520 */
521 conn_ptr = iscsit_get_conn_from_cid_rcfr(sess, cid);
522 if ((conn_ptr)) {
523 pr_err("Connection exists with CID %hu for %s,"
524 " performing connection reinstatement.\n",
525 conn_ptr->cid, sess->sess_ops->InitiatorName);
526
527 iscsit_connection_reinstatement_rcfr(conn_ptr);
528 iscsit_dec_conn_usage_count(conn_ptr);
529 }
530
531 /*
532 * Check for any connection recovery entires containing CID.
533 * We use the original ExpStatSN sent in the first login request
534 * to acknowledge commands for the failed connection.
535 *
536 * Also note that an explict logout may have already been sent,
537 * but the response may not be sent due to additional connection
538 * loss.
539 */
540 if (sess->sess_ops->ErrorRecoveryLevel == 2) {
541 cr = iscsit_get_inactive_connection_recovery_entry(
542 sess, cid);
543 if ((cr)) {
544 pr_debug("Performing implicit logout"
545 " for connection recovery on CID: %hu\n",
546 conn->cid);
547 iscsit_discard_cr_cmds_by_expstatsn(cr, exp_statsn);
548 }
549 }
550
551 /*
552 * Else we follow item 4 from the login table in that we have
553 * found an existing ISID and a valid/existing TSIH and a new
554 * CID we go ahead and continue to add a new connection to the
555 * session.
556 */
557 pr_debug("Adding CID %hu to existing session for %s.\n",
558 cid, sess->sess_ops->InitiatorName);
559
560 if ((atomic_read(&sess->nconn) + 1) > sess->sess_ops->MaxConnections) {
561 pr_err("Adding additional connection to this session"
562 " would exceed MaxConnections %d, login failed.\n",
563 sess->sess_ops->MaxConnections);
564 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
565 ISCSI_LOGIN_STATUS_ISID_ERROR);
566 return -1;
567 }
568
569 return 0;
570 }
571
572 static void iscsi_post_login_start_timers(struct iscsi_conn *conn)
573 {
574 struct iscsi_session *sess = conn->sess;
575
576 if (!sess->sess_ops->SessionType)
577 iscsit_start_nopin_timer(conn);
578 }
579
580 static int iscsi_post_login_handler(
581 struct iscsi_np *np,
582 struct iscsi_conn *conn,
583 u8 zero_tsih)
584 {
585 int stop_timer = 0;
586 struct iscsi_session *sess = conn->sess;
587 struct se_session *se_sess = sess->se_sess;
588 struct iscsi_portal_group *tpg = ISCSI_TPG_S(sess);
589 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
590 struct iscsi_thread_set *ts;
591
592 iscsit_inc_conn_usage_count(conn);
593
594 iscsit_collect_login_stats(conn, ISCSI_STATUS_CLS_SUCCESS,
595 ISCSI_LOGIN_STATUS_ACCEPT);
596
597 pr_debug("Moving to TARG_CONN_STATE_LOGGED_IN.\n");
598 conn->conn_state = TARG_CONN_STATE_LOGGED_IN;
599
600 iscsi_set_connection_parameters(conn->conn_ops, conn->param_list);
601 iscsit_set_sync_and_steering_values(conn);
602 /*
603 * SCSI Initiator -> SCSI Target Port Mapping
604 */
605 ts = iscsi_get_thread_set();
606 if (!zero_tsih) {
607 iscsi_set_session_parameters(sess->sess_ops,
608 conn->param_list, 0);
609 iscsi_release_param_list(conn->param_list);
610 conn->param_list = NULL;
611
612 spin_lock_bh(&sess->conn_lock);
613 atomic_set(&sess->session_continuation, 0);
614 if (sess->session_state == TARG_SESS_STATE_FAILED) {
615 pr_debug("Moving to"
616 " TARG_SESS_STATE_LOGGED_IN.\n");
617 sess->session_state = TARG_SESS_STATE_LOGGED_IN;
618 stop_timer = 1;
619 }
620
621 pr_debug("iSCSI Login successful on CID: %hu from %s to"
622 " %s:%hu,%hu\n", conn->cid, conn->login_ip,
623 conn->local_ip, conn->local_port, tpg->tpgt);
624
625 list_add_tail(&conn->conn_list, &sess->sess_conn_list);
626 atomic_inc(&sess->nconn);
627 pr_debug("Incremented iSCSI Connection count to %hu"
628 " from node: %s\n", atomic_read(&sess->nconn),
629 sess->sess_ops->InitiatorName);
630 spin_unlock_bh(&sess->conn_lock);
631
632 iscsi_post_login_start_timers(conn);
633 iscsi_activate_thread_set(conn, ts);
634 /*
635 * Determine CPU mask to ensure connection's RX and TX kthreads
636 * are scheduled on the same CPU.
637 */
638 iscsit_thread_get_cpumask(conn);
639 conn->conn_rx_reset_cpumask = 1;
640 conn->conn_tx_reset_cpumask = 1;
641
642 iscsit_dec_conn_usage_count(conn);
643 if (stop_timer) {
644 spin_lock_bh(&se_tpg->session_lock);
645 iscsit_stop_time2retain_timer(sess);
646 spin_unlock_bh(&se_tpg->session_lock);
647 }
648 iscsit_dec_session_usage_count(sess);
649 return 0;
650 }
651
652 iscsi_set_session_parameters(sess->sess_ops, conn->param_list, 1);
653 iscsi_release_param_list(conn->param_list);
654 conn->param_list = NULL;
655
656 iscsit_determine_maxcmdsn(sess);
657
658 spin_lock_bh(&se_tpg->session_lock);
659 __transport_register_session(&sess->tpg->tpg_se_tpg,
660 se_sess->se_node_acl, se_sess, sess);
661 pr_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n");
662 sess->session_state = TARG_SESS_STATE_LOGGED_IN;
663
664 pr_debug("iSCSI Login successful on CID: %hu from %s to %s:%hu,%hu\n",
665 conn->cid, conn->login_ip, conn->local_ip, conn->local_port,
666 tpg->tpgt);
667
668 spin_lock_bh(&sess->conn_lock);
669 list_add_tail(&conn->conn_list, &sess->sess_conn_list);
670 atomic_inc(&sess->nconn);
671 pr_debug("Incremented iSCSI Connection count to %hu from node:"
672 " %s\n", atomic_read(&sess->nconn),
673 sess->sess_ops->InitiatorName);
674 spin_unlock_bh(&sess->conn_lock);
675
676 sess->sid = tpg->sid++;
677 if (!sess->sid)
678 sess->sid = tpg->sid++;
679 pr_debug("Established iSCSI session from node: %s\n",
680 sess->sess_ops->InitiatorName);
681
682 tpg->nsessions++;
683 if (tpg->tpg_tiqn)
684 tpg->tpg_tiqn->tiqn_nsessions++;
685
686 pr_debug("Incremented number of active iSCSI sessions to %u on"
687 " iSCSI Target Portal Group: %hu\n", tpg->nsessions, tpg->tpgt);
688 spin_unlock_bh(&se_tpg->session_lock);
689
690 iscsi_post_login_start_timers(conn);
691 iscsi_activate_thread_set(conn, ts);
692 /*
693 * Determine CPU mask to ensure connection's RX and TX kthreads
694 * are scheduled on the same CPU.
695 */
696 iscsit_thread_get_cpumask(conn);
697 conn->conn_rx_reset_cpumask = 1;
698 conn->conn_tx_reset_cpumask = 1;
699
700 iscsit_dec_conn_usage_count(conn);
701
702 return 0;
703 }
704
705 static void iscsi_handle_login_thread_timeout(unsigned long data)
706 {
707 struct iscsi_np *np = (struct iscsi_np *) data;
708
709 spin_lock_bh(&np->np_thread_lock);
710 pr_err("iSCSI Login timeout on Network Portal %s:%hu\n",
711 np->np_ip, np->np_port);
712
713 if (np->np_login_timer_flags & ISCSI_TF_STOP) {
714 spin_unlock_bh(&np->np_thread_lock);
715 return;
716 }
717
718 if (np->np_thread)
719 send_sig(SIGINT, np->np_thread, 1);
720
721 np->np_login_timer_flags &= ~ISCSI_TF_RUNNING;
722 spin_unlock_bh(&np->np_thread_lock);
723 }
724
725 static void iscsi_start_login_thread_timer(struct iscsi_np *np)
726 {
727 /*
728 * This used the TA_LOGIN_TIMEOUT constant because at this
729 * point we do not have access to ISCSI_TPG_ATTRIB(tpg)->login_timeout
730 */
731 spin_lock_bh(&np->np_thread_lock);
732 init_timer(&np->np_login_timer);
733 np->np_login_timer.expires = (get_jiffies_64() + TA_LOGIN_TIMEOUT * HZ);
734 np->np_login_timer.data = (unsigned long)np;
735 np->np_login_timer.function = iscsi_handle_login_thread_timeout;
736 np->np_login_timer_flags &= ~ISCSI_TF_STOP;
737 np->np_login_timer_flags |= ISCSI_TF_RUNNING;
738 add_timer(&np->np_login_timer);
739
740 pr_debug("Added timeout timer to iSCSI login request for"
741 " %u seconds.\n", TA_LOGIN_TIMEOUT);
742 spin_unlock_bh(&np->np_thread_lock);
743 }
744
745 static void iscsi_stop_login_thread_timer(struct iscsi_np *np)
746 {
747 spin_lock_bh(&np->np_thread_lock);
748 if (!(np->np_login_timer_flags & ISCSI_TF_RUNNING)) {
749 spin_unlock_bh(&np->np_thread_lock);
750 return;
751 }
752 np->np_login_timer_flags |= ISCSI_TF_STOP;
753 spin_unlock_bh(&np->np_thread_lock);
754
755 del_timer_sync(&np->np_login_timer);
756
757 spin_lock_bh(&np->np_thread_lock);
758 np->np_login_timer_flags &= ~ISCSI_TF_RUNNING;
759 spin_unlock_bh(&np->np_thread_lock);
760 }
761
762 int iscsi_target_setup_login_socket(
763 struct iscsi_np *np,
764 struct __kernel_sockaddr_storage *sockaddr)
765 {
766 struct socket *sock;
767 int backlog = 5, ret, opt = 0, len;
768
769 switch (np->np_network_transport) {
770 case ISCSI_TCP:
771 np->np_ip_proto = IPPROTO_TCP;
772 np->np_sock_type = SOCK_STREAM;
773 break;
774 case ISCSI_SCTP_TCP:
775 np->np_ip_proto = IPPROTO_SCTP;
776 np->np_sock_type = SOCK_STREAM;
777 break;
778 case ISCSI_SCTP_UDP:
779 np->np_ip_proto = IPPROTO_SCTP;
780 np->np_sock_type = SOCK_SEQPACKET;
781 break;
782 case ISCSI_IWARP_TCP:
783 case ISCSI_IWARP_SCTP:
784 case ISCSI_INFINIBAND:
785 default:
786 pr_err("Unsupported network_transport: %d\n",
787 np->np_network_transport);
788 return -EINVAL;
789 }
790
791 ret = sock_create(sockaddr->ss_family, np->np_sock_type,
792 np->np_ip_proto, &sock);
793 if (ret < 0) {
794 pr_err("sock_create() failed.\n");
795 return ret;
796 }
797 np->np_socket = sock;
798 /*
799 * Setup the np->np_sockaddr from the passed sockaddr setup
800 * in iscsi_target_configfs.c code..
801 */
802 memcpy(&np->np_sockaddr, sockaddr,
803 sizeof(struct __kernel_sockaddr_storage));
804
805 if (sockaddr->ss_family == AF_INET6)
806 len = sizeof(struct sockaddr_in6);
807 else
808 len = sizeof(struct sockaddr_in);
809 /*
810 * Set SO_REUSEADDR, and disable Nagel Algorithm with TCP_NODELAY.
811 */
812 /* FIXME: Someone please explain why this is endian-safe */
813 opt = 1;
814 if (np->np_network_transport == ISCSI_TCP) {
815 ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
816 (char *)&opt, sizeof(opt));
817 if (ret < 0) {
818 pr_err("kernel_setsockopt() for TCP_NODELAY"
819 " failed: %d\n", ret);
820 goto fail;
821 }
822 }
823
824 /* FIXME: Someone please explain why this is endian-safe */
825 ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
826 (char *)&opt, sizeof(opt));
827 if (ret < 0) {
828 pr_err("kernel_setsockopt() for SO_REUSEADDR"
829 " failed\n");
830 goto fail;
831 }
832
833 ret = kernel_setsockopt(sock, IPPROTO_IP, IP_FREEBIND,
834 (char *)&opt, sizeof(opt));
835 if (ret < 0) {
836 pr_err("kernel_setsockopt() for IP_FREEBIND"
837 " failed\n");
838 goto fail;
839 }
840
841 ret = kernel_bind(sock, (struct sockaddr *)&np->np_sockaddr, len);
842 if (ret < 0) {
843 pr_err("kernel_bind() failed: %d\n", ret);
844 goto fail;
845 }
846
847 ret = kernel_listen(sock, backlog);
848 if (ret != 0) {
849 pr_err("kernel_listen() failed: %d\n", ret);
850 goto fail;
851 }
852
853 return 0;
854
855 fail:
856 np->np_socket = NULL;
857 if (sock)
858 sock_release(sock);
859 return ret;
860 }
861
862 static int __iscsi_target_login_thread(struct iscsi_np *np)
863 {
864 u8 buffer[ISCSI_HDR_LEN], iscsi_opcode, zero_tsih = 0;
865 int err, ret = 0, stop;
866 struct iscsi_conn *conn = NULL;
867 struct iscsi_login *login;
868 struct iscsi_portal_group *tpg = NULL;
869 struct socket *new_sock, *sock;
870 struct kvec iov;
871 struct iscsi_login_req *pdu;
872 struct sockaddr_in sock_in;
873 struct sockaddr_in6 sock_in6;
874
875 flush_signals(current);
876 sock = np->np_socket;
877
878 spin_lock_bh(&np->np_thread_lock);
879 if (np->np_thread_state == ISCSI_NP_THREAD_RESET) {
880 np->np_thread_state = ISCSI_NP_THREAD_ACTIVE;
881 complete(&np->np_restart_comp);
882 } else {
883 np->np_thread_state = ISCSI_NP_THREAD_ACTIVE;
884 }
885 spin_unlock_bh(&np->np_thread_lock);
886
887 if (kernel_accept(sock, &new_sock, 0) < 0) {
888 spin_lock_bh(&np->np_thread_lock);
889 if (np->np_thread_state == ISCSI_NP_THREAD_RESET) {
890 spin_unlock_bh(&np->np_thread_lock);
891 complete(&np->np_restart_comp);
892 /* Get another socket */
893 return 1;
894 }
895 spin_unlock_bh(&np->np_thread_lock);
896 goto out;
897 }
898 iscsi_start_login_thread_timer(np);
899
900 conn = kzalloc(sizeof(struct iscsi_conn), GFP_KERNEL);
901 if (!conn) {
902 pr_err("Could not allocate memory for"
903 " new connection\n");
904 sock_release(new_sock);
905 /* Get another socket */
906 return 1;
907 }
908
909 pr_debug("Moving to TARG_CONN_STATE_FREE.\n");
910 conn->conn_state = TARG_CONN_STATE_FREE;
911 conn->sock = new_sock;
912
913 pr_debug("Moving to TARG_CONN_STATE_XPT_UP.\n");
914 conn->conn_state = TARG_CONN_STATE_XPT_UP;
915
916 /*
917 * Allocate conn->conn_ops early as a failure calling
918 * iscsit_tx_login_rsp() below will call tx_data().
919 */
920 conn->conn_ops = kzalloc(sizeof(struct iscsi_conn_ops), GFP_KERNEL);
921 if (!conn->conn_ops) {
922 pr_err("Unable to allocate memory for"
923 " struct iscsi_conn_ops.\n");
924 goto new_sess_out;
925 }
926 /*
927 * Perform the remaining iSCSI connection initialization items..
928 */
929 if (iscsi_login_init_conn(conn) < 0)
930 goto new_sess_out;
931
932 memset(buffer, 0, ISCSI_HDR_LEN);
933 memset(&iov, 0, sizeof(struct kvec));
934 iov.iov_base = buffer;
935 iov.iov_len = ISCSI_HDR_LEN;
936
937 if (rx_data(conn, &iov, 1, ISCSI_HDR_LEN) <= 0) {
938 pr_err("rx_data() returned an error.\n");
939 goto new_sess_out;
940 }
941
942 iscsi_opcode = (buffer[0] & ISCSI_OPCODE_MASK);
943 if (!(iscsi_opcode & ISCSI_OP_LOGIN)) {
944 pr_err("First opcode is not login request,"
945 " failing login request.\n");
946 goto new_sess_out;
947 }
948
949 pdu = (struct iscsi_login_req *) buffer;
950 pdu->cid = be16_to_cpu(pdu->cid);
951 pdu->tsih = be16_to_cpu(pdu->tsih);
952 pdu->itt = be32_to_cpu(pdu->itt);
953 pdu->cmdsn = be32_to_cpu(pdu->cmdsn);
954 pdu->exp_statsn = be32_to_cpu(pdu->exp_statsn);
955 /*
956 * Used by iscsit_tx_login_rsp() for Login Resonses PDUs
957 * when Status-Class != 0.
958 */
959 conn->login_itt = pdu->itt;
960
961 spin_lock_bh(&np->np_thread_lock);
962 if (np->np_thread_state != ISCSI_NP_THREAD_ACTIVE) {
963 spin_unlock_bh(&np->np_thread_lock);
964 pr_err("iSCSI Network Portal on %s:%hu currently not"
965 " active.\n", np->np_ip, np->np_port);
966 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
967 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
968 goto new_sess_out;
969 }
970 spin_unlock_bh(&np->np_thread_lock);
971
972 if (np->np_sockaddr.ss_family == AF_INET6) {
973 memset(&sock_in6, 0, sizeof(struct sockaddr_in6));
974
975 if (conn->sock->ops->getname(conn->sock,
976 (struct sockaddr *)&sock_in6, &err, 1) < 0) {
977 pr_err("sock_ops->getname() failed.\n");
978 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
979 ISCSI_LOGIN_STATUS_TARGET_ERROR);
980 goto new_sess_out;
981 }
982 snprintf(conn->login_ip, sizeof(conn->login_ip), "%pI6c",
983 &sock_in6.sin6_addr.in6_u);
984 conn->login_port = ntohs(sock_in6.sin6_port);
985
986 if (conn->sock->ops->getname(conn->sock,
987 (struct sockaddr *)&sock_in6, &err, 0) < 0) {
988 pr_err("sock_ops->getname() failed.\n");
989 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
990 ISCSI_LOGIN_STATUS_TARGET_ERROR);
991 goto new_sess_out;
992 }
993 snprintf(conn->local_ip, sizeof(conn->local_ip), "%pI6c",
994 &sock_in6.sin6_addr.in6_u);
995 conn->local_port = ntohs(sock_in6.sin6_port);
996
997 } else {
998 memset(&sock_in, 0, sizeof(struct sockaddr_in));
999
1000 if (conn->sock->ops->getname(conn->sock,
1001 (struct sockaddr *)&sock_in, &err, 1) < 0) {
1002 pr_err("sock_ops->getname() failed.\n");
1003 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
1004 ISCSI_LOGIN_STATUS_TARGET_ERROR);
1005 goto new_sess_out;
1006 }
1007 sprintf(conn->login_ip, "%pI4", &sock_in.sin_addr.s_addr);
1008 conn->login_port = ntohs(sock_in.sin_port);
1009
1010 if (conn->sock->ops->getname(conn->sock,
1011 (struct sockaddr *)&sock_in, &err, 0) < 0) {
1012 pr_err("sock_ops->getname() failed.\n");
1013 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
1014 ISCSI_LOGIN_STATUS_TARGET_ERROR);
1015 goto new_sess_out;
1016 }
1017 sprintf(conn->local_ip, "%pI4", &sock_in.sin_addr.s_addr);
1018 conn->local_port = ntohs(sock_in.sin_port);
1019 }
1020
1021 conn->network_transport = np->np_network_transport;
1022
1023 pr_debug("Received iSCSI login request from %s on %s Network"
1024 " Portal %s:%hu\n", conn->login_ip,
1025 (conn->network_transport == ISCSI_TCP) ? "TCP" : "SCTP",
1026 conn->local_ip, conn->local_port);
1027
1028 pr_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n");
1029 conn->conn_state = TARG_CONN_STATE_IN_LOGIN;
1030
1031 if (iscsi_login_check_initiator_version(conn, pdu->max_version,
1032 pdu->min_version) < 0)
1033 goto new_sess_out;
1034
1035 zero_tsih = (pdu->tsih == 0x0000);
1036 if ((zero_tsih)) {
1037 /*
1038 * This is the leading connection of a new session.
1039 * We wait until after authentication to check for
1040 * session reinstatement.
1041 */
1042 if (iscsi_login_zero_tsih_s1(conn, buffer) < 0)
1043 goto new_sess_out;
1044 } else {
1045 /*
1046 * Add a new connection to an existing session.
1047 * We check for a non-existant session in
1048 * iscsi_login_non_zero_tsih_s2() below based
1049 * on ISID/TSIH, but wait until after authentication
1050 * to check for connection reinstatement, etc.
1051 */
1052 if (iscsi_login_non_zero_tsih_s1(conn, buffer) < 0)
1053 goto new_sess_out;
1054 }
1055
1056 /*
1057 * This will process the first login request, and call
1058 * iscsi_target_locate_portal(), and return a valid struct iscsi_login.
1059 */
1060 login = iscsi_target_init_negotiation(np, conn, buffer);
1061 if (!login) {
1062 tpg = conn->tpg;
1063 goto new_sess_out;
1064 }
1065
1066 tpg = conn->tpg;
1067 if (!tpg) {
1068 pr_err("Unable to locate struct iscsi_conn->tpg\n");
1069 goto new_sess_out;
1070 }
1071
1072 if (zero_tsih) {
1073 if (iscsi_login_zero_tsih_s2(conn) < 0) {
1074 iscsi_target_nego_release(login, conn);
1075 goto new_sess_out;
1076 }
1077 } else {
1078 if (iscsi_login_non_zero_tsih_s2(conn, buffer) < 0) {
1079 iscsi_target_nego_release(login, conn);
1080 goto old_sess_out;
1081 }
1082 }
1083
1084 if (iscsi_target_start_negotiation(login, conn) < 0)
1085 goto new_sess_out;
1086
1087 if (!conn->sess) {
1088 pr_err("struct iscsi_conn session pointer is NULL!\n");
1089 goto new_sess_out;
1090 }
1091
1092 iscsi_stop_login_thread_timer(np);
1093
1094 if (signal_pending(current))
1095 goto new_sess_out;
1096
1097 ret = iscsi_post_login_handler(np, conn, zero_tsih);
1098
1099 if (ret < 0)
1100 goto new_sess_out;
1101
1102 iscsit_deaccess_np(np, tpg);
1103 tpg = NULL;
1104 /* Get another socket */
1105 return 1;
1106
1107 new_sess_out:
1108 pr_err("iSCSI Login negotiation failed.\n");
1109 iscsit_collect_login_stats(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
1110 ISCSI_LOGIN_STATUS_INIT_ERR);
1111 if (!zero_tsih || !conn->sess)
1112 goto old_sess_out;
1113 if (conn->sess->se_sess)
1114 transport_free_session(conn->sess->se_sess);
1115 if (conn->sess->session_index != 0) {
1116 spin_lock_bh(&sess_idr_lock);
1117 idr_remove(&sess_idr, conn->sess->session_index);
1118 spin_unlock_bh(&sess_idr_lock);
1119 }
1120 if (conn->sess->sess_ops)
1121 kfree(conn->sess->sess_ops);
1122 if (conn->sess)
1123 kfree(conn->sess);
1124 old_sess_out:
1125 iscsi_stop_login_thread_timer(np);
1126 /*
1127 * If login negotiation fails check if the Time2Retain timer
1128 * needs to be restarted.
1129 */
1130 if (!zero_tsih && conn->sess) {
1131 spin_lock_bh(&conn->sess->conn_lock);
1132 if (conn->sess->session_state == TARG_SESS_STATE_FAILED) {
1133 struct se_portal_group *se_tpg =
1134 &ISCSI_TPG_C(conn)->tpg_se_tpg;
1135
1136 atomic_set(&conn->sess->session_continuation, 0);
1137 spin_unlock_bh(&conn->sess->conn_lock);
1138 spin_lock_bh(&se_tpg->session_lock);
1139 iscsit_start_time2retain_handler(conn->sess);
1140 spin_unlock_bh(&se_tpg->session_lock);
1141 } else
1142 spin_unlock_bh(&conn->sess->conn_lock);
1143 iscsit_dec_session_usage_count(conn->sess);
1144 }
1145
1146 if (!IS_ERR(conn->conn_rx_hash.tfm))
1147 crypto_free_hash(conn->conn_rx_hash.tfm);
1148 if (!IS_ERR(conn->conn_tx_hash.tfm))
1149 crypto_free_hash(conn->conn_tx_hash.tfm);
1150
1151 if (conn->conn_cpumask)
1152 free_cpumask_var(conn->conn_cpumask);
1153
1154 kfree(conn->conn_ops);
1155
1156 if (conn->param_list) {
1157 iscsi_release_param_list(conn->param_list);
1158 conn->param_list = NULL;
1159 }
1160 if (conn->sock)
1161 sock_release(conn->sock);
1162 kfree(conn);
1163
1164 if (tpg) {
1165 iscsit_deaccess_np(np, tpg);
1166 tpg = NULL;
1167 }
1168
1169 out:
1170 stop = kthread_should_stop();
1171 if (!stop && signal_pending(current)) {
1172 spin_lock_bh(&np->np_thread_lock);
1173 stop = (np->np_thread_state == ISCSI_NP_THREAD_SHUTDOWN);
1174 spin_unlock_bh(&np->np_thread_lock);
1175 }
1176 /* Wait for another socket.. */
1177 if (!stop)
1178 return 1;
1179
1180 iscsi_stop_login_thread_timer(np);
1181 spin_lock_bh(&np->np_thread_lock);
1182 np->np_thread_state = ISCSI_NP_THREAD_EXIT;
1183 spin_unlock_bh(&np->np_thread_lock);
1184 return 0;
1185 }
1186
1187 int iscsi_target_login_thread(void *arg)
1188 {
1189 struct iscsi_np *np = arg;
1190 int ret;
1191
1192 allow_signal(SIGINT);
1193
1194 while (!kthread_should_stop()) {
1195 ret = __iscsi_target_login_thread(np);
1196 /*
1197 * We break and exit here unless another sock_accept() call
1198 * is expected.
1199 */
1200 if (ret != 1)
1201 break;
1202 }
1203
1204 return 0;
1205 }
Linux with added FPC-III support