1 /*******************************************************************************
2 * This file contains the login functions used by the iSCSI Target driver.
4 * (c) Copyright 2007-2013 Datera, Inc.
6 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 ******************************************************************************/
19 #include <linux/string.h>
20 #include <linux/kthread.h>
21 #include <linux/crypto.h>
22 #include <linux/idr.h>
23 #include <scsi/iscsi_proto.h>
24 #include <target/target_core_base.h>
25 #include <target/target_core_fabric.h>
27 #include <target/iscsi/iscsi_target_core.h>
28 #include <target/iscsi/iscsi_target_stat.h>
29 #include "iscsi_target_device.h"
30 #include "iscsi_target_nego.h"
31 #include "iscsi_target_erl0.h"
32 #include "iscsi_target_erl2.h"
33 #include "iscsi_target_login.h"
34 #include "iscsi_target_tpg.h"
35 #include "iscsi_target_util.h"
36 #include "iscsi_target.h"
37 #include "iscsi_target_parameters.h"
39 #include <target/iscsi/iscsi_transport.h>
41 static struct iscsi_login
*iscsi_login_init_conn(struct iscsi_conn
*conn
)
43 struct iscsi_login
*login
;
45 login
= kzalloc(sizeof(struct iscsi_login
), GFP_KERNEL
);
47 pr_err("Unable to allocate memory for struct iscsi_login.\n");
52 login
->first_request
= 1;
54 login
->req_buf
= kzalloc(MAX_KEY_VALUE_PAIRS
, GFP_KERNEL
);
55 if (!login
->req_buf
) {
56 pr_err("Unable to allocate memory for response buffer.\n");
60 login
->rsp_buf
= kzalloc(MAX_KEY_VALUE_PAIRS
, GFP_KERNEL
);
61 if (!login
->rsp_buf
) {
62 pr_err("Unable to allocate memory for request buffer.\n");
66 conn
->conn_ops
= kzalloc(sizeof(struct iscsi_conn_ops
), GFP_KERNEL
);
67 if (!conn
->conn_ops
) {
68 pr_err("Unable to allocate memory for"
69 " struct iscsi_conn_ops.\n");
73 init_waitqueue_head(&conn
->queues_wq
);
74 INIT_LIST_HEAD(&conn
->conn_list
);
75 INIT_LIST_HEAD(&conn
->conn_cmd_list
);
76 INIT_LIST_HEAD(&conn
->immed_queue_list
);
77 INIT_LIST_HEAD(&conn
->response_queue_list
);
78 init_completion(&conn
->conn_post_wait_comp
);
79 init_completion(&conn
->conn_wait_comp
);
80 init_completion(&conn
->conn_wait_rcfr_comp
);
81 init_completion(&conn
->conn_waiting_on_uc_comp
);
82 init_completion(&conn
->conn_logout_comp
);
83 init_completion(&conn
->rx_half_close_comp
);
84 init_completion(&conn
->tx_half_close_comp
);
85 spin_lock_init(&conn
->cmd_lock
);
86 spin_lock_init(&conn
->conn_usage_lock
);
87 spin_lock_init(&conn
->immed_queue_lock
);
88 spin_lock_init(&conn
->nopin_timer_lock
);
89 spin_lock_init(&conn
->response_queue_lock
);
90 spin_lock_init(&conn
->state_lock
);
92 if (!zalloc_cpumask_var(&conn
->conn_cpumask
, GFP_KERNEL
)) {
93 pr_err("Unable to allocate conn->conn_cpumask\n");
96 conn
->conn_login
= login
;
101 kfree(conn
->conn_ops
);
103 kfree(login
->rsp_buf
);
105 kfree(login
->req_buf
);
112 * Used by iscsi_target_nego.c:iscsi_target_locate_portal() to setup
113 * per struct iscsi_conn libcrypto contexts for crc32c and crc32-intel
115 int iscsi_login_setup_crypto(struct iscsi_conn
*conn
)
118 * Setup slicing by CRC32C algorithm for RX and TX libcrypto contexts
119 * which will default to crc32c_intel.ko for cpu_has_xmm4_2, or fallback
120 * to software 1x8 byte slicing from crc32c.ko
122 conn
->conn_rx_hash
.flags
= 0;
123 conn
->conn_rx_hash
.tfm
= crypto_alloc_hash("crc32c", 0,
125 if (IS_ERR(conn
->conn_rx_hash
.tfm
)) {
126 pr_err("crypto_alloc_hash() failed for conn_rx_tfm\n");
130 conn
->conn_tx_hash
.flags
= 0;
131 conn
->conn_tx_hash
.tfm
= crypto_alloc_hash("crc32c", 0,
133 if (IS_ERR(conn
->conn_tx_hash
.tfm
)) {
134 pr_err("crypto_alloc_hash() failed for conn_tx_tfm\n");
135 crypto_free_hash(conn
->conn_rx_hash
.tfm
);
142 static int iscsi_login_check_initiator_version(
143 struct iscsi_conn
*conn
,
147 if ((version_max
!= 0x00) || (version_min
!= 0x00)) {
148 pr_err("Unsupported iSCSI IETF Pre-RFC Revision,"
149 " version Min/Max 0x%02x/0x%02x, rejecting login.\n",
150 version_min
, version_max
);
151 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
152 ISCSI_LOGIN_STATUS_NO_VERSION
);
159 int iscsi_check_for_session_reinstatement(struct iscsi_conn
*conn
)
162 struct iscsi_param
*initiatorname_param
= NULL
, *sessiontype_param
= NULL
;
163 struct iscsi_portal_group
*tpg
= conn
->tpg
;
164 struct iscsi_session
*sess
= NULL
, *sess_p
= NULL
;
165 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
166 struct se_session
*se_sess
, *se_sess_tmp
;
168 initiatorname_param
= iscsi_find_param_from_key(
169 INITIATORNAME
, conn
->param_list
);
170 sessiontype_param
= iscsi_find_param_from_key(
171 SESSIONTYPE
, conn
->param_list
);
172 if (!initiatorname_param
|| !sessiontype_param
) {
173 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
174 ISCSI_LOGIN_STATUS_MISSING_FIELDS
);
178 sessiontype
= (strncmp(sessiontype_param
->value
, NORMAL
, 6)) ? 1 : 0;
180 spin_lock_bh(&se_tpg
->session_lock
);
181 list_for_each_entry_safe(se_sess
, se_sess_tmp
, &se_tpg
->tpg_sess_list
,
184 sess_p
= se_sess
->fabric_sess_ptr
;
185 spin_lock(&sess_p
->conn_lock
);
186 if (atomic_read(&sess_p
->session_fall_back_to_erl0
) ||
187 atomic_read(&sess_p
->session_logout
) ||
188 (sess_p
->time2retain_timer_flags
& ISCSI_TF_EXPIRED
)) {
189 spin_unlock(&sess_p
->conn_lock
);
192 if (!memcmp(sess_p
->isid
, conn
->sess
->isid
, 6) &&
193 (!strcmp(sess_p
->sess_ops
->InitiatorName
,
194 initiatorname_param
->value
) &&
195 (sess_p
->sess_ops
->SessionType
== sessiontype
))) {
196 atomic_set(&sess_p
->session_reinstatement
, 1);
197 spin_unlock(&sess_p
->conn_lock
);
198 iscsit_inc_session_usage_count(sess_p
);
199 iscsit_stop_time2retain_timer(sess_p
);
203 spin_unlock(&sess_p
->conn_lock
);
205 spin_unlock_bh(&se_tpg
->session_lock
);
207 * If the Time2Retain handler has expired, the session is already gone.
212 pr_debug("%s iSCSI Session SID %u is still active for %s,"
213 " preforming session reinstatement.\n", (sessiontype
) ?
214 "Discovery" : "Normal", sess
->sid
,
215 sess
->sess_ops
->InitiatorName
);
217 spin_lock_bh(&sess
->conn_lock
);
218 if (sess
->session_state
== TARG_SESS_STATE_FAILED
) {
219 spin_unlock_bh(&sess
->conn_lock
);
220 iscsit_dec_session_usage_count(sess
);
221 target_put_session(sess
->se_sess
);
224 spin_unlock_bh(&sess
->conn_lock
);
226 iscsit_stop_session(sess
, 1, 1);
227 iscsit_dec_session_usage_count(sess
);
229 target_put_session(sess
->se_sess
);
233 static void iscsi_login_set_conn_values(
234 struct iscsi_session
*sess
,
235 struct iscsi_conn
*conn
,
239 conn
->cid
= be16_to_cpu(cid
);
241 * Generate a random Status sequence number (statsn) for the new
244 get_random_bytes(&conn
->stat_sn
, sizeof(u32
));
246 mutex_lock(&auth_id_lock
);
247 conn
->auth_id
= iscsit_global
->auth_id
++;
248 mutex_unlock(&auth_id_lock
);
251 static __printf(2, 3) int iscsi_change_param_sprintf(
252 struct iscsi_conn
*conn
,
253 const char *fmt
, ...)
256 unsigned char buf
[64];
258 memset(buf
, 0, sizeof buf
);
261 vsnprintf(buf
, sizeof buf
, fmt
, args
);
264 if (iscsi_change_param_value(buf
, conn
->param_list
, 0) < 0) {
265 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
266 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
274 * This is the leading connection of a new session,
275 * or session reinstatement.
277 static int iscsi_login_zero_tsih_s1(
278 struct iscsi_conn
*conn
,
281 struct iscsi_session
*sess
= NULL
;
282 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
285 sess
= kzalloc(sizeof(struct iscsi_session
), GFP_KERNEL
);
287 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
288 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
289 pr_err("Could not allocate memory for session\n");
293 iscsi_login_set_conn_values(sess
, conn
, pdu
->cid
);
294 sess
->init_task_tag
= pdu
->itt
;
295 memcpy(&sess
->isid
, pdu
->isid
, 6);
296 sess
->exp_cmd_sn
= be32_to_cpu(pdu
->cmdsn
);
297 INIT_LIST_HEAD(&sess
->sess_conn_list
);
298 INIT_LIST_HEAD(&sess
->sess_ooo_cmdsn_list
);
299 INIT_LIST_HEAD(&sess
->cr_active_list
);
300 INIT_LIST_HEAD(&sess
->cr_inactive_list
);
301 init_completion(&sess
->async_msg_comp
);
302 init_completion(&sess
->reinstatement_comp
);
303 init_completion(&sess
->session_wait_comp
);
304 init_completion(&sess
->session_waiting_on_uc_comp
);
305 mutex_init(&sess
->cmdsn_mutex
);
306 spin_lock_init(&sess
->conn_lock
);
307 spin_lock_init(&sess
->cr_a_lock
);
308 spin_lock_init(&sess
->cr_i_lock
);
309 spin_lock_init(&sess
->session_usage_lock
);
310 spin_lock_init(&sess
->ttt_lock
);
312 idr_preload(GFP_KERNEL
);
313 spin_lock_bh(&sess_idr_lock
);
314 ret
= idr_alloc(&sess_idr
, NULL
, 0, 0, GFP_NOWAIT
);
316 sess
->session_index
= ret
;
317 spin_unlock_bh(&sess_idr_lock
);
321 pr_err("idr_alloc() for sess_idr failed\n");
322 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
323 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
328 sess
->creation_time
= get_jiffies_64();
330 * The FFP CmdSN window values will be allocated from the TPG's
331 * Initiator Node's ACL once the login has been successfully completed.
333 sess
->max_cmd_sn
= be32_to_cpu(pdu
->cmdsn
);
335 sess
->sess_ops
= kzalloc(sizeof(struct iscsi_sess_ops
), GFP_KERNEL
);
336 if (!sess
->sess_ops
) {
337 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
338 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
339 pr_err("Unable to allocate memory for"
340 " struct iscsi_sess_ops.\n");
345 sess
->se_sess
= transport_init_session(TARGET_PROT_NORMAL
);
346 if (IS_ERR(sess
->se_sess
)) {
347 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
348 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
349 kfree(sess
->sess_ops
);
357 static int iscsi_login_zero_tsih_s2(
358 struct iscsi_conn
*conn
)
360 struct iscsi_node_attrib
*na
;
361 struct iscsi_session
*sess
= conn
->sess
;
364 sess
->tpg
= conn
->tpg
;
367 * Assign a new TPG Session Handle. Note this is protected with
368 * struct iscsi_portal_group->np_login_sem from iscsit_access_np().
370 sess
->tsih
= ++sess
->tpg
->ntsih
;
372 sess
->tsih
= ++sess
->tpg
->ntsih
;
375 * Create the default params from user defined values..
377 if (iscsi_copy_param_list(&conn
->param_list
,
378 conn
->tpg
->param_list
, 1) < 0) {
379 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
380 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
384 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
387 iscsi_set_keys_to_negotiate(conn
->param_list
, iser
);
389 if (sess
->sess_ops
->SessionType
)
390 return iscsi_set_keys_irrelevant_for_discovery(
393 na
= iscsit_tpg_get_node_attrib(sess
);
396 * Need to send TargetPortalGroupTag back in first login response
397 * on any iSCSI connection where the Initiator provides TargetName.
398 * See 5.3.1. Login Phase Start
400 * In our case, we have already located the struct iscsi_tiqn at this point.
402 if (iscsi_change_param_sprintf(conn
, "TargetPortalGroupTag=%hu", sess
->tpg
->tpgt
))
406 * Workaround for Initiators that have broken connection recovery logic.
408 * "We would really like to get rid of this." Linux-iSCSI.org team
410 if (iscsi_change_param_sprintf(conn
, "ErrorRecoveryLevel=%d", na
->default_erl
))
413 if (iscsi_login_disable_FIM_keys(conn
->param_list
, conn
) < 0)
416 * Set RDMAExtensions=Yes by default for iSER enabled network portals
419 struct iscsi_param
*param
;
420 unsigned long mrdsl
, off
;
423 if (iscsi_change_param_sprintf(conn
, "RDMAExtensions=Yes"))
427 * Make MaxRecvDataSegmentLength PAGE_SIZE aligned for
428 * Immediate Data + Unsolicitied Data-OUT if necessary..
430 param
= iscsi_find_param_from_key("MaxRecvDataSegmentLength",
433 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
434 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
437 rc
= kstrtoul(param
->value
, 0, &mrdsl
);
439 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
440 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
443 off
= mrdsl
% PAGE_SIZE
;
447 if (mrdsl
< PAGE_SIZE
)
452 pr_warn("Aligning ISER MaxRecvDataSegmentLength: %lu down"
453 " to PAGE_SIZE\n", mrdsl
);
455 if (iscsi_change_param_sprintf(conn
, "MaxRecvDataSegmentLength=%lu\n", mrdsl
))
458 * ISER currently requires that ImmediateData + Unsolicited
459 * Data be disabled when protection / signature MRs are enabled.
462 if (sess
->se_sess
->sup_prot_ops
&
463 (TARGET_PROT_DOUT_STRIP
| TARGET_PROT_DOUT_PASS
|
464 TARGET_PROT_DOUT_INSERT
)) {
466 if (iscsi_change_param_sprintf(conn
, "ImmediateData=No"))
469 if (iscsi_change_param_sprintf(conn
, "InitialR2T=Yes"))
472 pr_debug("Forcing ImmediateData=No + InitialR2T=Yes for"
473 " T10-PI enabled ISER session\n");
481 * Remove PSTATE_NEGOTIATE for the four FIM related keys.
482 * The Initiator node will be able to enable FIM by proposing them itself.
484 int iscsi_login_disable_FIM_keys(
485 struct iscsi_param_list
*param_list
,
486 struct iscsi_conn
*conn
)
488 struct iscsi_param
*param
;
490 param
= iscsi_find_param_from_key("OFMarker", param_list
);
492 pr_err("iscsi_find_param_from_key() for"
493 " OFMarker failed\n");
494 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
495 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
498 param
->state
&= ~PSTATE_NEGOTIATE
;
500 param
= iscsi_find_param_from_key("OFMarkInt", param_list
);
502 pr_err("iscsi_find_param_from_key() for"
503 " IFMarker failed\n");
504 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
505 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
508 param
->state
&= ~PSTATE_NEGOTIATE
;
510 param
= iscsi_find_param_from_key("IFMarker", param_list
);
512 pr_err("iscsi_find_param_from_key() for"
513 " IFMarker failed\n");
514 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
515 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
518 param
->state
&= ~PSTATE_NEGOTIATE
;
520 param
= iscsi_find_param_from_key("IFMarkInt", param_list
);
522 pr_err("iscsi_find_param_from_key() for"
523 " IFMarker failed\n");
524 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
525 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
528 param
->state
&= ~PSTATE_NEGOTIATE
;
533 static int iscsi_login_non_zero_tsih_s1(
534 struct iscsi_conn
*conn
,
537 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
539 iscsi_login_set_conn_values(NULL
, conn
, pdu
->cid
);
544 * Add a new connection to an existing session.
546 static int iscsi_login_non_zero_tsih_s2(
547 struct iscsi_conn
*conn
,
550 struct iscsi_portal_group
*tpg
= conn
->tpg
;
551 struct iscsi_session
*sess
= NULL
, *sess_p
= NULL
;
552 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
553 struct se_session
*se_sess
, *se_sess_tmp
;
554 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
557 spin_lock_bh(&se_tpg
->session_lock
);
558 list_for_each_entry_safe(se_sess
, se_sess_tmp
, &se_tpg
->tpg_sess_list
,
561 sess_p
= (struct iscsi_session
*)se_sess
->fabric_sess_ptr
;
562 if (atomic_read(&sess_p
->session_fall_back_to_erl0
) ||
563 atomic_read(&sess_p
->session_logout
) ||
564 (sess_p
->time2retain_timer_flags
& ISCSI_TF_EXPIRED
))
566 if (!memcmp(sess_p
->isid
, pdu
->isid
, 6) &&
567 (sess_p
->tsih
== be16_to_cpu(pdu
->tsih
))) {
568 iscsit_inc_session_usage_count(sess_p
);
569 iscsit_stop_time2retain_timer(sess_p
);
574 spin_unlock_bh(&se_tpg
->session_lock
);
577 * If the Time2Retain handler has expired, the session is already gone.
580 pr_err("Initiator attempting to add a connection to"
581 " a non-existent session, rejecting iSCSI Login.\n");
582 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
583 ISCSI_LOGIN_STATUS_NO_SESSION
);
588 * Stop the Time2Retain timer if this is a failed session, we restart
589 * the timer if the login is not successful.
591 spin_lock_bh(&sess
->conn_lock
);
592 if (sess
->session_state
== TARG_SESS_STATE_FAILED
)
593 atomic_set(&sess
->session_continuation
, 1);
594 spin_unlock_bh(&sess
->conn_lock
);
596 iscsi_login_set_conn_values(sess
, conn
, pdu
->cid
);
598 if (iscsi_copy_param_list(&conn
->param_list
,
599 conn
->tpg
->param_list
, 0) < 0) {
600 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
601 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
605 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
608 iscsi_set_keys_to_negotiate(conn
->param_list
, iser
);
610 * Need to send TargetPortalGroupTag back in first login response
611 * on any iSCSI connection where the Initiator provides TargetName.
612 * See 5.3.1. Login Phase Start
614 * In our case, we have already located the struct iscsi_tiqn at this point.
616 if (iscsi_change_param_sprintf(conn
, "TargetPortalGroupTag=%hu", sess
->tpg
->tpgt
))
619 return iscsi_login_disable_FIM_keys(conn
->param_list
, conn
);
622 int iscsi_login_post_auth_non_zero_tsih(
623 struct iscsi_conn
*conn
,
627 struct iscsi_conn
*conn_ptr
= NULL
;
628 struct iscsi_conn_recovery
*cr
= NULL
;
629 struct iscsi_session
*sess
= conn
->sess
;
632 * By following item 5 in the login table, if we have found
633 * an existing ISID and a valid/existing TSIH and an existing
634 * CID we do connection reinstatement. Currently we dont not
635 * support it so we send back an non-zero status class to the
636 * initiator and release the new connection.
638 conn_ptr
= iscsit_get_conn_from_cid_rcfr(sess
, cid
);
640 pr_err("Connection exists with CID %hu for %s,"
641 " performing connection reinstatement.\n",
642 conn_ptr
->cid
, sess
->sess_ops
->InitiatorName
);
644 iscsit_connection_reinstatement_rcfr(conn_ptr
);
645 iscsit_dec_conn_usage_count(conn_ptr
);
649 * Check for any connection recovery entires containing CID.
650 * We use the original ExpStatSN sent in the first login request
651 * to acknowledge commands for the failed connection.
653 * Also note that an explict logout may have already been sent,
654 * but the response may not be sent due to additional connection
657 if (sess
->sess_ops
->ErrorRecoveryLevel
== 2) {
658 cr
= iscsit_get_inactive_connection_recovery_entry(
661 pr_debug("Performing implicit logout"
662 " for connection recovery on CID: %hu\n",
664 iscsit_discard_cr_cmds_by_expstatsn(cr
, exp_statsn
);
669 * Else we follow item 4 from the login table in that we have
670 * found an existing ISID and a valid/existing TSIH and a new
671 * CID we go ahead and continue to add a new connection to the
674 pr_debug("Adding CID %hu to existing session for %s.\n",
675 cid
, sess
->sess_ops
->InitiatorName
);
677 if ((atomic_read(&sess
->nconn
) + 1) > sess
->sess_ops
->MaxConnections
) {
678 pr_err("Adding additional connection to this session"
679 " would exceed MaxConnections %d, login failed.\n",
680 sess
->sess_ops
->MaxConnections
);
681 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
682 ISCSI_LOGIN_STATUS_ISID_ERROR
);
689 static void iscsi_post_login_start_timers(struct iscsi_conn
*conn
)
691 struct iscsi_session
*sess
= conn
->sess
;
693 * FIXME: Unsolicitied NopIN support for ISER
695 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
698 if (!sess
->sess_ops
->SessionType
)
699 iscsit_start_nopin_timer(conn
);
702 static int iscsit_start_kthreads(struct iscsi_conn
*conn
)
706 spin_lock(&iscsit_global
->ts_bitmap_lock
);
707 conn
->bitmap_id
= bitmap_find_free_region(iscsit_global
->ts_bitmap
,
708 ISCSIT_BITMAP_BITS
, get_order(1));
709 spin_unlock(&iscsit_global
->ts_bitmap_lock
);
711 if (conn
->bitmap_id
< 0) {
712 pr_err("bitmap_find_free_region() failed for"
713 " iscsit_start_kthreads()\n");
717 conn
->tx_thread
= kthread_run(iscsi_target_tx_thread
, conn
,
718 "%s", ISCSI_TX_THREAD_NAME
);
719 if (IS_ERR(conn
->tx_thread
)) {
720 pr_err("Unable to start iscsi_target_tx_thread\n");
721 ret
= PTR_ERR(conn
->tx_thread
);
724 conn
->tx_thread_active
= true;
726 conn
->rx_thread
= kthread_run(iscsi_target_rx_thread
, conn
,
727 "%s", ISCSI_RX_THREAD_NAME
);
728 if (IS_ERR(conn
->rx_thread
)) {
729 pr_err("Unable to start iscsi_target_rx_thread\n");
730 ret
= PTR_ERR(conn
->rx_thread
);
733 conn
->rx_thread_active
= true;
737 kthread_stop(conn
->tx_thread
);
738 conn
->tx_thread_active
= false;
740 spin_lock(&iscsit_global
->ts_bitmap_lock
);
741 bitmap_release_region(iscsit_global
->ts_bitmap
, conn
->bitmap_id
,
743 spin_unlock(&iscsit_global
->ts_bitmap_lock
);
747 int iscsi_post_login_handler(
749 struct iscsi_conn
*conn
,
753 struct iscsi_session
*sess
= conn
->sess
;
754 struct se_session
*se_sess
= sess
->se_sess
;
755 struct iscsi_portal_group
*tpg
= sess
->tpg
;
756 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
759 iscsit_inc_conn_usage_count(conn
);
761 iscsit_collect_login_stats(conn
, ISCSI_STATUS_CLS_SUCCESS
,
762 ISCSI_LOGIN_STATUS_ACCEPT
);
764 pr_debug("Moving to TARG_CONN_STATE_LOGGED_IN.\n");
765 conn
->conn_state
= TARG_CONN_STATE_LOGGED_IN
;
767 iscsi_set_connection_parameters(conn
->conn_ops
, conn
->param_list
);
768 iscsit_set_sync_and_steering_values(conn
);
770 * SCSI Initiator -> SCSI Target Port Mapping
773 iscsi_set_session_parameters(sess
->sess_ops
,
774 conn
->param_list
, 0);
775 iscsi_release_param_list(conn
->param_list
);
776 conn
->param_list
= NULL
;
778 spin_lock_bh(&sess
->conn_lock
);
779 atomic_set(&sess
->session_continuation
, 0);
780 if (sess
->session_state
== TARG_SESS_STATE_FAILED
) {
782 " TARG_SESS_STATE_LOGGED_IN.\n");
783 sess
->session_state
= TARG_SESS_STATE_LOGGED_IN
;
787 pr_debug("iSCSI Login successful on CID: %hu from %s to"
788 " %s:%hu,%hu\n", conn
->cid
, conn
->login_ip
,
789 conn
->local_ip
, conn
->local_port
, tpg
->tpgt
);
791 list_add_tail(&conn
->conn_list
, &sess
->sess_conn_list
);
792 atomic_inc(&sess
->nconn
);
793 pr_debug("Incremented iSCSI Connection count to %hu"
794 " from node: %s\n", atomic_read(&sess
->nconn
),
795 sess
->sess_ops
->InitiatorName
);
796 spin_unlock_bh(&sess
->conn_lock
);
798 rc
= iscsit_start_kthreads(conn
);
802 iscsi_post_login_start_timers(conn
);
804 * Determine CPU mask to ensure connection's RX and TX kthreads
805 * are scheduled on the same CPU.
807 iscsit_thread_get_cpumask(conn
);
808 conn
->conn_rx_reset_cpumask
= 1;
809 conn
->conn_tx_reset_cpumask
= 1;
811 iscsit_dec_conn_usage_count(conn
);
813 spin_lock_bh(&se_tpg
->session_lock
);
814 iscsit_stop_time2retain_timer(sess
);
815 spin_unlock_bh(&se_tpg
->session_lock
);
817 iscsit_dec_session_usage_count(sess
);
821 iscsi_set_session_parameters(sess
->sess_ops
, conn
->param_list
, 1);
822 iscsi_release_param_list(conn
->param_list
);
823 conn
->param_list
= NULL
;
825 iscsit_determine_maxcmdsn(sess
);
827 spin_lock_bh(&se_tpg
->session_lock
);
828 __transport_register_session(&sess
->tpg
->tpg_se_tpg
,
829 se_sess
->se_node_acl
, se_sess
, sess
);
830 pr_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n");
831 sess
->session_state
= TARG_SESS_STATE_LOGGED_IN
;
833 pr_debug("iSCSI Login successful on CID: %hu from %s to %s:%hu,%hu\n",
834 conn
->cid
, conn
->login_ip
, conn
->local_ip
, conn
->local_port
,
837 spin_lock_bh(&sess
->conn_lock
);
838 list_add_tail(&conn
->conn_list
, &sess
->sess_conn_list
);
839 atomic_inc(&sess
->nconn
);
840 pr_debug("Incremented iSCSI Connection count to %hu from node:"
841 " %s\n", atomic_read(&sess
->nconn
),
842 sess
->sess_ops
->InitiatorName
);
843 spin_unlock_bh(&sess
->conn_lock
);
845 sess
->sid
= tpg
->sid
++;
847 sess
->sid
= tpg
->sid
++;
848 pr_debug("Established iSCSI session from node: %s\n",
849 sess
->sess_ops
->InitiatorName
);
853 tpg
->tpg_tiqn
->tiqn_nsessions
++;
855 pr_debug("Incremented number of active iSCSI sessions to %u on"
856 " iSCSI Target Portal Group: %hu\n", tpg
->nsessions
, tpg
->tpgt
);
857 spin_unlock_bh(&se_tpg
->session_lock
);
859 rc
= iscsit_start_kthreads(conn
);
863 iscsi_post_login_start_timers(conn
);
865 * Determine CPU mask to ensure connection's RX and TX kthreads
866 * are scheduled on the same CPU.
868 iscsit_thread_get_cpumask(conn
);
869 conn
->conn_rx_reset_cpumask
= 1;
870 conn
->conn_tx_reset_cpumask
= 1;
872 iscsit_dec_conn_usage_count(conn
);
877 static void iscsi_handle_login_thread_timeout(unsigned long data
)
879 struct iscsi_np
*np
= (struct iscsi_np
*) data
;
881 spin_lock_bh(&np
->np_thread_lock
);
882 pr_err("iSCSI Login timeout on Network Portal %s:%hu\n",
883 np
->np_ip
, np
->np_port
);
885 if (np
->np_login_timer_flags
& ISCSI_TF_STOP
) {
886 spin_unlock_bh(&np
->np_thread_lock
);
891 send_sig(SIGINT
, np
->np_thread
, 1);
893 np
->np_login_timer_flags
&= ~ISCSI_TF_RUNNING
;
894 spin_unlock_bh(&np
->np_thread_lock
);
897 static void iscsi_start_login_thread_timer(struct iscsi_np
*np
)
900 * This used the TA_LOGIN_TIMEOUT constant because at this
901 * point we do not have access to ISCSI_TPG_ATTRIB(tpg)->login_timeout
903 spin_lock_bh(&np
->np_thread_lock
);
904 init_timer(&np
->np_login_timer
);
905 np
->np_login_timer
.expires
= (get_jiffies_64() + TA_LOGIN_TIMEOUT
* HZ
);
906 np
->np_login_timer
.data
= (unsigned long)np
;
907 np
->np_login_timer
.function
= iscsi_handle_login_thread_timeout
;
908 np
->np_login_timer_flags
&= ~ISCSI_TF_STOP
;
909 np
->np_login_timer_flags
|= ISCSI_TF_RUNNING
;
910 add_timer(&np
->np_login_timer
);
912 pr_debug("Added timeout timer to iSCSI login request for"
913 " %u seconds.\n", TA_LOGIN_TIMEOUT
);
914 spin_unlock_bh(&np
->np_thread_lock
);
917 static void iscsi_stop_login_thread_timer(struct iscsi_np
*np
)
919 spin_lock_bh(&np
->np_thread_lock
);
920 if (!(np
->np_login_timer_flags
& ISCSI_TF_RUNNING
)) {
921 spin_unlock_bh(&np
->np_thread_lock
);
924 np
->np_login_timer_flags
|= ISCSI_TF_STOP
;
925 spin_unlock_bh(&np
->np_thread_lock
);
927 del_timer_sync(&np
->np_login_timer
);
929 spin_lock_bh(&np
->np_thread_lock
);
930 np
->np_login_timer_flags
&= ~ISCSI_TF_RUNNING
;
931 spin_unlock_bh(&np
->np_thread_lock
);
936 struct __kernel_sockaddr_storage
*sockaddr
)
938 struct socket
*sock
= NULL
;
939 int backlog
= ISCSIT_TCP_BACKLOG
, ret
, opt
= 0, len
;
941 switch (np
->np_network_transport
) {
943 np
->np_ip_proto
= IPPROTO_TCP
;
944 np
->np_sock_type
= SOCK_STREAM
;
947 np
->np_ip_proto
= IPPROTO_SCTP
;
948 np
->np_sock_type
= SOCK_STREAM
;
951 np
->np_ip_proto
= IPPROTO_SCTP
;
952 np
->np_sock_type
= SOCK_SEQPACKET
;
955 pr_err("Unsupported network_transport: %d\n",
956 np
->np_network_transport
);
960 np
->np_ip_proto
= IPPROTO_TCP
;
961 np
->np_sock_type
= SOCK_STREAM
;
963 ret
= sock_create(sockaddr
->ss_family
, np
->np_sock_type
,
964 np
->np_ip_proto
, &sock
);
966 pr_err("sock_create() failed.\n");
969 np
->np_socket
= sock
;
971 * Setup the np->np_sockaddr from the passed sockaddr setup
972 * in iscsi_target_configfs.c code..
974 memcpy(&np
->np_sockaddr
, sockaddr
,
975 sizeof(struct __kernel_sockaddr_storage
));
977 if (sockaddr
->ss_family
== AF_INET6
)
978 len
= sizeof(struct sockaddr_in6
);
980 len
= sizeof(struct sockaddr_in
);
982 * Set SO_REUSEADDR, and disable Nagel Algorithm with TCP_NODELAY.
984 /* FIXME: Someone please explain why this is endian-safe */
986 if (np
->np_network_transport
== ISCSI_TCP
) {
987 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_NODELAY
,
988 (char *)&opt
, sizeof(opt
));
990 pr_err("kernel_setsockopt() for TCP_NODELAY"
991 " failed: %d\n", ret
);
996 /* FIXME: Someone please explain why this is endian-safe */
997 ret
= kernel_setsockopt(sock
, SOL_SOCKET
, SO_REUSEADDR
,
998 (char *)&opt
, sizeof(opt
));
1000 pr_err("kernel_setsockopt() for SO_REUSEADDR"
1005 ret
= kernel_setsockopt(sock
, IPPROTO_IP
, IP_FREEBIND
,
1006 (char *)&opt
, sizeof(opt
));
1008 pr_err("kernel_setsockopt() for IP_FREEBIND"
1013 ret
= kernel_bind(sock
, (struct sockaddr
*)&np
->np_sockaddr
, len
);
1015 pr_err("kernel_bind() failed: %d\n", ret
);
1019 ret
= kernel_listen(sock
, backlog
);
1021 pr_err("kernel_listen() failed: %d\n", ret
);
1027 np
->np_socket
= NULL
;
1032 int iscsi_target_setup_login_socket(
1033 struct iscsi_np
*np
,
1034 struct __kernel_sockaddr_storage
*sockaddr
)
1036 struct iscsit_transport
*t
;
1039 t
= iscsit_get_transport(np
->np_network_transport
);
1043 rc
= t
->iscsit_setup_np(np
, sockaddr
);
1045 iscsit_put_transport(t
);
1049 np
->np_transport
= t
;
1054 int iscsit_accept_np(struct iscsi_np
*np
, struct iscsi_conn
*conn
)
1056 struct socket
*new_sock
, *sock
= np
->np_socket
;
1057 struct sockaddr_in sock_in
;
1058 struct sockaddr_in6 sock_in6
;
1061 rc
= kernel_accept(sock
, &new_sock
, 0);
1065 conn
->sock
= new_sock
;
1066 conn
->login_family
= np
->np_sockaddr
.ss_family
;
1068 if (np
->np_sockaddr
.ss_family
== AF_INET6
) {
1069 memset(&sock_in6
, 0, sizeof(struct sockaddr_in6
));
1071 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1072 (struct sockaddr
*)&sock_in6
, &err
, 1);
1074 if (!ipv6_addr_v4mapped(&sock_in6
.sin6_addr
))
1075 snprintf(conn
->login_ip
, sizeof(conn
->login_ip
), "[%pI6c]",
1076 &sock_in6
.sin6_addr
.in6_u
);
1078 snprintf(conn
->login_ip
, sizeof(conn
->login_ip
), "%pI4",
1079 &sock_in6
.sin6_addr
.s6_addr32
[3]);
1080 conn
->login_port
= ntohs(sock_in6
.sin6_port
);
1083 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1084 (struct sockaddr
*)&sock_in6
, &err
, 0);
1086 if (!ipv6_addr_v4mapped(&sock_in6
.sin6_addr
))
1087 snprintf(conn
->local_ip
, sizeof(conn
->local_ip
), "[%pI6c]",
1088 &sock_in6
.sin6_addr
.in6_u
);
1090 snprintf(conn
->local_ip
, sizeof(conn
->local_ip
), "%pI4",
1091 &sock_in6
.sin6_addr
.s6_addr32
[3]);
1092 conn
->local_port
= ntohs(sock_in6
.sin6_port
);
1095 memset(&sock_in
, 0, sizeof(struct sockaddr_in
));
1097 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1098 (struct sockaddr
*)&sock_in
, &err
, 1);
1100 sprintf(conn
->login_ip
, "%pI4",
1101 &sock_in
.sin_addr
.s_addr
);
1102 conn
->login_port
= ntohs(sock_in
.sin_port
);
1105 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1106 (struct sockaddr
*)&sock_in
, &err
, 0);
1108 sprintf(conn
->local_ip
, "%pI4",
1109 &sock_in
.sin_addr
.s_addr
);
1110 conn
->local_port
= ntohs(sock_in
.sin_port
);
1117 int iscsit_get_login_rx(struct iscsi_conn
*conn
, struct iscsi_login
*login
)
1119 struct iscsi_login_req
*login_req
;
1120 u32 padding
= 0, payload_length
;
1122 if (iscsi_login_rx_data(conn
, login
->req
, ISCSI_HDR_LEN
) < 0)
1125 login_req
= (struct iscsi_login_req
*)login
->req
;
1126 payload_length
= ntoh24(login_req
->dlength
);
1127 padding
= ((-payload_length
) & 3);
1129 pr_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x,"
1130 " CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
1131 login_req
->flags
, login_req
->itt
, login_req
->cmdsn
,
1132 login_req
->exp_statsn
, login_req
->cid
, payload_length
);
1134 * Setup the initial iscsi_login values from the leading
1135 * login request PDU.
1137 if (login
->first_request
) {
1138 login_req
= (struct iscsi_login_req
*)login
->req
;
1139 login
->leading_connection
= (!login_req
->tsih
) ? 1 : 0;
1140 login
->current_stage
= ISCSI_LOGIN_CURRENT_STAGE(login_req
->flags
);
1141 login
->version_min
= login_req
->min_version
;
1142 login
->version_max
= login_req
->max_version
;
1143 memcpy(login
->isid
, login_req
->isid
, 6);
1144 login
->cmd_sn
= be32_to_cpu(login_req
->cmdsn
);
1145 login
->init_task_tag
= login_req
->itt
;
1146 login
->initial_exp_statsn
= be32_to_cpu(login_req
->exp_statsn
);
1147 login
->cid
= be16_to_cpu(login_req
->cid
);
1148 login
->tsih
= be16_to_cpu(login_req
->tsih
);
1151 if (iscsi_target_check_login_request(conn
, login
) < 0)
1154 memset(login
->req_buf
, 0, MAX_KEY_VALUE_PAIRS
);
1155 if (iscsi_login_rx_data(conn
, login
->req_buf
,
1156 payload_length
+ padding
) < 0)
1162 int iscsit_put_login_tx(struct iscsi_conn
*conn
, struct iscsi_login
*login
,
1165 if (iscsi_login_tx_data(conn
, login
->rsp
, login
->rsp_buf
, length
) < 0)
1172 iscsit_conn_set_transport(struct iscsi_conn
*conn
, struct iscsit_transport
*t
)
1177 conn
->conn_transport
= t
;
1181 rc
= try_module_get(t
->owner
);
1183 pr_err("try_module_get() failed for %s\n", t
->name
);
1187 conn
->conn_transport
= t
;
1191 void iscsi_target_login_sess_out(struct iscsi_conn
*conn
,
1192 struct iscsi_np
*np
, bool zero_tsih
, bool new_sess
)
1197 pr_err("iSCSI Login negotiation failed.\n");
1198 iscsit_collect_login_stats(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
1199 ISCSI_LOGIN_STATUS_INIT_ERR
);
1200 if (!zero_tsih
|| !conn
->sess
)
1202 if (conn
->sess
->se_sess
)
1203 transport_free_session(conn
->sess
->se_sess
);
1204 if (conn
->sess
->session_index
!= 0) {
1205 spin_lock_bh(&sess_idr_lock
);
1206 idr_remove(&sess_idr
, conn
->sess
->session_index
);
1207 spin_unlock_bh(&sess_idr_lock
);
1209 kfree(conn
->sess
->sess_ops
);
1214 iscsi_stop_login_thread_timer(np
);
1216 * If login negotiation fails check if the Time2Retain timer
1217 * needs to be restarted.
1219 if (!zero_tsih
&& conn
->sess
) {
1220 spin_lock_bh(&conn
->sess
->conn_lock
);
1221 if (conn
->sess
->session_state
== TARG_SESS_STATE_FAILED
) {
1222 struct se_portal_group
*se_tpg
=
1223 &conn
->tpg
->tpg_se_tpg
;
1225 atomic_set(&conn
->sess
->session_continuation
, 0);
1226 spin_unlock_bh(&conn
->sess
->conn_lock
);
1227 spin_lock_bh(&se_tpg
->session_lock
);
1228 iscsit_start_time2retain_handler(conn
->sess
);
1229 spin_unlock_bh(&se_tpg
->session_lock
);
1231 spin_unlock_bh(&conn
->sess
->conn_lock
);
1232 iscsit_dec_session_usage_count(conn
->sess
);
1235 if (!IS_ERR(conn
->conn_rx_hash
.tfm
))
1236 crypto_free_hash(conn
->conn_rx_hash
.tfm
);
1237 if (!IS_ERR(conn
->conn_tx_hash
.tfm
))
1238 crypto_free_hash(conn
->conn_tx_hash
.tfm
);
1240 free_cpumask_var(conn
->conn_cpumask
);
1242 kfree(conn
->conn_ops
);
1244 if (conn
->param_list
) {
1245 iscsi_release_param_list(conn
->param_list
);
1246 conn
->param_list
= NULL
;
1248 iscsi_target_nego_release(conn
);
1251 sock_release(conn
->sock
);
1255 if (conn
->conn_transport
->iscsit_wait_conn
)
1256 conn
->conn_transport
->iscsit_wait_conn(conn
);
1258 if (conn
->conn_transport
->iscsit_free_conn
)
1259 conn
->conn_transport
->iscsit_free_conn(conn
);
1261 iscsit_put_transport(conn
->conn_transport
);
1265 static int __iscsi_target_login_thread(struct iscsi_np
*np
)
1267 u8
*buffer
, zero_tsih
= 0;
1269 struct iscsi_conn
*conn
= NULL
;
1270 struct iscsi_login
*login
;
1271 struct iscsi_portal_group
*tpg
= NULL
;
1272 struct iscsi_login_req
*pdu
;
1273 struct iscsi_tpg_np
*tpg_np
;
1274 bool new_sess
= false;
1276 flush_signals(current
);
1278 spin_lock_bh(&np
->np_thread_lock
);
1279 if (np
->np_thread_state
== ISCSI_NP_THREAD_RESET
) {
1280 np
->np_thread_state
= ISCSI_NP_THREAD_ACTIVE
;
1281 complete(&np
->np_restart_comp
);
1282 } else if (np
->np_thread_state
== ISCSI_NP_THREAD_SHUTDOWN
) {
1283 spin_unlock_bh(&np
->np_thread_lock
);
1286 np
->np_thread_state
= ISCSI_NP_THREAD_ACTIVE
;
1288 spin_unlock_bh(&np
->np_thread_lock
);
1290 conn
= kzalloc(sizeof(struct iscsi_conn
), GFP_KERNEL
);
1292 pr_err("Could not allocate memory for"
1293 " new connection\n");
1294 /* Get another socket */
1297 pr_debug("Moving to TARG_CONN_STATE_FREE.\n");
1298 conn
->conn_state
= TARG_CONN_STATE_FREE
;
1300 if (iscsit_conn_set_transport(conn
, np
->np_transport
) < 0) {
1305 rc
= np
->np_transport
->iscsit_accept_np(np
, conn
);
1306 if (rc
== -ENOSYS
) {
1307 complete(&np
->np_restart_comp
);
1308 iscsit_put_transport(conn
->conn_transport
);
1312 } else if (rc
< 0) {
1313 spin_lock_bh(&np
->np_thread_lock
);
1314 if (np
->np_thread_state
== ISCSI_NP_THREAD_RESET
) {
1315 spin_unlock_bh(&np
->np_thread_lock
);
1316 complete(&np
->np_restart_comp
);
1317 iscsit_put_transport(conn
->conn_transport
);
1320 /* Get another socket */
1323 spin_unlock_bh(&np
->np_thread_lock
);
1324 iscsit_put_transport(conn
->conn_transport
);
1330 * Perform the remaining iSCSI connection initialization items..
1332 login
= iscsi_login_init_conn(conn
);
1337 iscsi_start_login_thread_timer(np
);
1339 pr_debug("Moving to TARG_CONN_STATE_XPT_UP.\n");
1340 conn
->conn_state
= TARG_CONN_STATE_XPT_UP
;
1342 * This will process the first login request + payload..
1344 rc
= np
->np_transport
->iscsit_get_login_rx(conn
, login
);
1350 buffer
= &login
->req
[0];
1351 pdu
= (struct iscsi_login_req
*)buffer
;
1353 * Used by iscsit_tx_login_rsp() for Login Resonses PDUs
1354 * when Status-Class != 0.
1356 conn
->login_itt
= pdu
->itt
;
1358 spin_lock_bh(&np
->np_thread_lock
);
1359 if (np
->np_thread_state
!= ISCSI_NP_THREAD_ACTIVE
) {
1360 spin_unlock_bh(&np
->np_thread_lock
);
1361 pr_err("iSCSI Network Portal on %s:%hu currently not"
1362 " active.\n", np
->np_ip
, np
->np_port
);
1363 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
1364 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE
);
1367 spin_unlock_bh(&np
->np_thread_lock
);
1369 conn
->network_transport
= np
->np_network_transport
;
1371 pr_debug("Received iSCSI login request from %s on %s Network"
1372 " Portal %s:%hu\n", conn
->login_ip
, np
->np_transport
->name
,
1373 conn
->local_ip
, conn
->local_port
);
1375 pr_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n");
1376 conn
->conn_state
= TARG_CONN_STATE_IN_LOGIN
;
1378 if (iscsi_login_check_initiator_version(conn
, pdu
->max_version
,
1379 pdu
->min_version
) < 0)
1382 zero_tsih
= (pdu
->tsih
== 0x0000);
1385 * This is the leading connection of a new session.
1386 * We wait until after authentication to check for
1387 * session reinstatement.
1389 if (iscsi_login_zero_tsih_s1(conn
, buffer
) < 0)
1393 * Add a new connection to an existing session.
1394 * We check for a non-existant session in
1395 * iscsi_login_non_zero_tsih_s2() below based
1396 * on ISID/TSIH, but wait until after authentication
1397 * to check for connection reinstatement, etc.
1399 if (iscsi_login_non_zero_tsih_s1(conn
, buffer
) < 0)
1403 * SessionType: Discovery
1405 * Locates Default Portal
1407 * SessionType: Normal
1409 * Locates Target Portal from NP -> Target IQN
1411 rc
= iscsi_target_locate_portal(np
, conn
, login
);
1416 login
->zero_tsih
= zero_tsih
;
1418 conn
->sess
->se_sess
->sup_prot_ops
=
1419 conn
->conn_transport
->iscsit_get_sup_prot_ops(conn
);
1423 pr_err("Unable to locate struct iscsi_conn->tpg\n");
1428 if (iscsi_login_zero_tsih_s2(conn
) < 0)
1431 if (iscsi_login_non_zero_tsih_s2(conn
, buffer
) < 0)
1435 ret
= iscsi_target_start_negotiation(login
, conn
);
1440 pr_err("struct iscsi_conn session pointer is NULL!\n");
1444 iscsi_stop_login_thread_timer(np
);
1446 if (signal_pending(current
))
1450 tpg_np
= conn
->tpg_np
;
1452 ret
= iscsi_post_login_handler(np
, conn
, zero_tsih
);
1456 iscsit_deaccess_np(np
, tpg
, tpg_np
);
1461 /* Get another socket */
1467 tpg_np
= conn
->tpg_np
;
1468 iscsi_target_login_sess_out(conn
, np
, zero_tsih
, new_sess
);
1472 iscsit_deaccess_np(np
, tpg
, tpg_np
);
1481 iscsi_stop_login_thread_timer(np
);
1482 spin_lock_bh(&np
->np_thread_lock
);
1483 np
->np_thread_state
= ISCSI_NP_THREAD_EXIT
;
1484 spin_unlock_bh(&np
->np_thread_lock
);
1489 int iscsi_target_login_thread(void *arg
)
1491 struct iscsi_np
*np
= arg
;
1494 allow_signal(SIGINT
);
1497 ret
= __iscsi_target_login_thread(np
);
1499 * We break and exit here unless another sock_accept() call