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 <crypto/hash.h>
20 #include <linux/module.h>
21 #include <linux/string.h>
22 #include <linux/kthread.h>
23 #include <linux/sched/signal.h>
24 #include <linux/idr.h>
25 #include <linux/tcp.h> /* TCP_NODELAY */
26 #include <net/ipv6.h> /* ipv6_addr_v4mapped() */
27 #include <scsi/iscsi_proto.h>
28 #include <target/target_core_base.h>
29 #include <target/target_core_fabric.h>
31 #include <target/iscsi/iscsi_target_core.h>
32 #include <target/iscsi/iscsi_target_stat.h>
33 #include "iscsi_target_device.h"
34 #include "iscsi_target_nego.h"
35 #include "iscsi_target_erl0.h"
36 #include "iscsi_target_erl2.h"
37 #include "iscsi_target_login.h"
38 #include "iscsi_target_tpg.h"
39 #include "iscsi_target_util.h"
40 #include "iscsi_target.h"
41 #include "iscsi_target_parameters.h"
43 #include <target/iscsi/iscsi_transport.h>
45 static struct iscsi_login
*iscsi_login_init_conn(struct iscsi_conn
*conn
)
47 struct iscsi_login
*login
;
49 login
= kzalloc(sizeof(struct iscsi_login
), GFP_KERNEL
);
51 pr_err("Unable to allocate memory for struct iscsi_login.\n");
56 login
->first_request
= 1;
58 login
->req_buf
= kzalloc(MAX_KEY_VALUE_PAIRS
, GFP_KERNEL
);
59 if (!login
->req_buf
) {
60 pr_err("Unable to allocate memory for response buffer.\n");
64 login
->rsp_buf
= kzalloc(MAX_KEY_VALUE_PAIRS
, GFP_KERNEL
);
65 if (!login
->rsp_buf
) {
66 pr_err("Unable to allocate memory for request buffer.\n");
70 conn
->conn_ops
= kzalloc(sizeof(struct iscsi_conn_ops
), GFP_KERNEL
);
71 if (!conn
->conn_ops
) {
72 pr_err("Unable to allocate memory for"
73 " struct iscsi_conn_ops.\n");
77 init_waitqueue_head(&conn
->queues_wq
);
78 INIT_LIST_HEAD(&conn
->conn_list
);
79 INIT_LIST_HEAD(&conn
->conn_cmd_list
);
80 INIT_LIST_HEAD(&conn
->immed_queue_list
);
81 INIT_LIST_HEAD(&conn
->response_queue_list
);
82 init_completion(&conn
->conn_post_wait_comp
);
83 init_completion(&conn
->conn_wait_comp
);
84 init_completion(&conn
->conn_wait_rcfr_comp
);
85 init_completion(&conn
->conn_waiting_on_uc_comp
);
86 init_completion(&conn
->conn_logout_comp
);
87 init_completion(&conn
->rx_half_close_comp
);
88 init_completion(&conn
->tx_half_close_comp
);
89 init_completion(&conn
->rx_login_comp
);
90 spin_lock_init(&conn
->cmd_lock
);
91 spin_lock_init(&conn
->conn_usage_lock
);
92 spin_lock_init(&conn
->immed_queue_lock
);
93 spin_lock_init(&conn
->nopin_timer_lock
);
94 spin_lock_init(&conn
->response_queue_lock
);
95 spin_lock_init(&conn
->state_lock
);
97 if (!zalloc_cpumask_var(&conn
->conn_cpumask
, GFP_KERNEL
)) {
98 pr_err("Unable to allocate conn->conn_cpumask\n");
101 conn
->conn_login
= login
;
106 kfree(conn
->conn_ops
);
108 kfree(login
->rsp_buf
);
110 kfree(login
->req_buf
);
117 * Used by iscsi_target_nego.c:iscsi_target_locate_portal() to setup
118 * per struct iscsi_conn libcrypto contexts for crc32c and crc32-intel
120 int iscsi_login_setup_crypto(struct iscsi_conn
*conn
)
122 struct crypto_ahash
*tfm
;
125 * Setup slicing by CRC32C algorithm for RX and TX libcrypto contexts
126 * which will default to crc32c_intel.ko for cpu_has_xmm4_2, or fallback
127 * to software 1x8 byte slicing from crc32c.ko
129 tfm
= crypto_alloc_ahash("crc32c", 0, CRYPTO_ALG_ASYNC
);
131 pr_err("crypto_alloc_ahash() failed\n");
135 conn
->conn_rx_hash
= ahash_request_alloc(tfm
, GFP_KERNEL
);
136 if (!conn
->conn_rx_hash
) {
137 pr_err("ahash_request_alloc() failed for conn_rx_hash\n");
138 crypto_free_ahash(tfm
);
141 ahash_request_set_callback(conn
->conn_rx_hash
, 0, NULL
, NULL
);
143 conn
->conn_tx_hash
= ahash_request_alloc(tfm
, GFP_KERNEL
);
144 if (!conn
->conn_tx_hash
) {
145 pr_err("ahash_request_alloc() failed for conn_tx_hash\n");
146 ahash_request_free(conn
->conn_rx_hash
);
147 conn
->conn_rx_hash
= NULL
;
148 crypto_free_ahash(tfm
);
151 ahash_request_set_callback(conn
->conn_tx_hash
, 0, NULL
, NULL
);
156 static int iscsi_login_check_initiator_version(
157 struct iscsi_conn
*conn
,
161 if ((version_max
!= 0x00) || (version_min
!= 0x00)) {
162 pr_err("Unsupported iSCSI IETF Pre-RFC Revision,"
163 " version Min/Max 0x%02x/0x%02x, rejecting login.\n",
164 version_min
, version_max
);
165 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
166 ISCSI_LOGIN_STATUS_NO_VERSION
);
173 int iscsi_check_for_session_reinstatement(struct iscsi_conn
*conn
)
176 struct iscsi_param
*initiatorname_param
= NULL
, *sessiontype_param
= NULL
;
177 struct iscsi_portal_group
*tpg
= conn
->tpg
;
178 struct iscsi_session
*sess
= NULL
, *sess_p
= NULL
;
179 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
180 struct se_session
*se_sess
, *se_sess_tmp
;
182 initiatorname_param
= iscsi_find_param_from_key(
183 INITIATORNAME
, conn
->param_list
);
184 sessiontype_param
= iscsi_find_param_from_key(
185 SESSIONTYPE
, conn
->param_list
);
186 if (!initiatorname_param
|| !sessiontype_param
) {
187 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
188 ISCSI_LOGIN_STATUS_MISSING_FIELDS
);
192 sessiontype
= (strncmp(sessiontype_param
->value
, NORMAL
, 6)) ? 1 : 0;
194 spin_lock_bh(&se_tpg
->session_lock
);
195 list_for_each_entry_safe(se_sess
, se_sess_tmp
, &se_tpg
->tpg_sess_list
,
198 sess_p
= se_sess
->fabric_sess_ptr
;
199 spin_lock(&sess_p
->conn_lock
);
200 if (atomic_read(&sess_p
->session_fall_back_to_erl0
) ||
201 atomic_read(&sess_p
->session_logout
) ||
202 (sess_p
->time2retain_timer_flags
& ISCSI_TF_EXPIRED
)) {
203 spin_unlock(&sess_p
->conn_lock
);
206 if (!memcmp(sess_p
->isid
, conn
->sess
->isid
, 6) &&
207 (!strcmp(sess_p
->sess_ops
->InitiatorName
,
208 initiatorname_param
->value
) &&
209 (sess_p
->sess_ops
->SessionType
== sessiontype
))) {
210 atomic_set(&sess_p
->session_reinstatement
, 1);
211 atomic_set(&sess_p
->session_fall_back_to_erl0
, 1);
212 spin_unlock(&sess_p
->conn_lock
);
213 iscsit_inc_session_usage_count(sess_p
);
214 iscsit_stop_time2retain_timer(sess_p
);
218 spin_unlock(&sess_p
->conn_lock
);
220 spin_unlock_bh(&se_tpg
->session_lock
);
222 * If the Time2Retain handler has expired, the session is already gone.
227 pr_debug("%s iSCSI Session SID %u is still active for %s,"
228 " performing session reinstatement.\n", (sessiontype
) ?
229 "Discovery" : "Normal", sess
->sid
,
230 sess
->sess_ops
->InitiatorName
);
232 spin_lock_bh(&sess
->conn_lock
);
233 if (sess
->session_state
== TARG_SESS_STATE_FAILED
) {
234 spin_unlock_bh(&sess
->conn_lock
);
235 iscsit_dec_session_usage_count(sess
);
236 iscsit_close_session(sess
);
239 spin_unlock_bh(&sess
->conn_lock
);
241 iscsit_stop_session(sess
, 1, 1);
242 iscsit_dec_session_usage_count(sess
);
244 iscsit_close_session(sess
);
248 static void iscsi_login_set_conn_values(
249 struct iscsi_session
*sess
,
250 struct iscsi_conn
*conn
,
254 conn
->cid
= be16_to_cpu(cid
);
256 * Generate a random Status sequence number (statsn) for the new
259 get_random_bytes(&conn
->stat_sn
, sizeof(u32
));
261 mutex_lock(&auth_id_lock
);
262 conn
->auth_id
= iscsit_global
->auth_id
++;
263 mutex_unlock(&auth_id_lock
);
266 __printf(2, 3) int iscsi_change_param_sprintf(
267 struct iscsi_conn
*conn
,
268 const char *fmt
, ...)
271 unsigned char buf
[64];
273 memset(buf
, 0, sizeof buf
);
276 vsnprintf(buf
, sizeof buf
, fmt
, args
);
279 if (iscsi_change_param_value(buf
, conn
->param_list
, 0) < 0) {
280 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
281 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
287 EXPORT_SYMBOL(iscsi_change_param_sprintf
);
290 * This is the leading connection of a new session,
291 * or session reinstatement.
293 static int iscsi_login_zero_tsih_s1(
294 struct iscsi_conn
*conn
,
297 struct iscsi_session
*sess
= NULL
;
298 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
301 sess
= kzalloc(sizeof(struct iscsi_session
), GFP_KERNEL
);
303 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
304 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
305 pr_err("Could not allocate memory for session\n");
309 iscsi_login_set_conn_values(sess
, conn
, pdu
->cid
);
310 sess
->init_task_tag
= pdu
->itt
;
311 memcpy(&sess
->isid
, pdu
->isid
, 6);
312 sess
->exp_cmd_sn
= be32_to_cpu(pdu
->cmdsn
);
313 INIT_LIST_HEAD(&sess
->sess_conn_list
);
314 INIT_LIST_HEAD(&sess
->sess_ooo_cmdsn_list
);
315 INIT_LIST_HEAD(&sess
->cr_active_list
);
316 INIT_LIST_HEAD(&sess
->cr_inactive_list
);
317 init_completion(&sess
->async_msg_comp
);
318 init_completion(&sess
->reinstatement_comp
);
319 init_completion(&sess
->session_wait_comp
);
320 init_completion(&sess
->session_waiting_on_uc_comp
);
321 mutex_init(&sess
->cmdsn_mutex
);
322 spin_lock_init(&sess
->conn_lock
);
323 spin_lock_init(&sess
->cr_a_lock
);
324 spin_lock_init(&sess
->cr_i_lock
);
325 spin_lock_init(&sess
->session_usage_lock
);
326 spin_lock_init(&sess
->ttt_lock
);
328 idr_preload(GFP_KERNEL
);
329 spin_lock_bh(&sess_idr_lock
);
330 ret
= idr_alloc(&sess_idr
, NULL
, 0, 0, GFP_NOWAIT
);
332 sess
->session_index
= ret
;
333 spin_unlock_bh(&sess_idr_lock
);
337 pr_err("idr_alloc() for sess_idr failed\n");
338 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
339 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
344 sess
->creation_time
= get_jiffies_64();
346 * The FFP CmdSN window values will be allocated from the TPG's
347 * Initiator Node's ACL once the login has been successfully completed.
349 atomic_set(&sess
->max_cmd_sn
, be32_to_cpu(pdu
->cmdsn
));
351 sess
->sess_ops
= kzalloc(sizeof(struct iscsi_sess_ops
), GFP_KERNEL
);
352 if (!sess
->sess_ops
) {
353 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
354 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
355 pr_err("Unable to allocate memory for"
356 " struct iscsi_sess_ops.\n");
361 sess
->se_sess
= transport_init_session(TARGET_PROT_NORMAL
);
362 if (IS_ERR(sess
->se_sess
)) {
363 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
364 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
365 kfree(sess
->sess_ops
);
373 static int iscsi_login_zero_tsih_s2(
374 struct iscsi_conn
*conn
)
376 struct iscsi_node_attrib
*na
;
377 struct iscsi_session
*sess
= conn
->sess
;
380 sess
->tpg
= conn
->tpg
;
383 * Assign a new TPG Session Handle. Note this is protected with
384 * struct iscsi_portal_group->np_login_sem from iscsit_access_np().
386 sess
->tsih
= ++sess
->tpg
->ntsih
;
388 sess
->tsih
= ++sess
->tpg
->ntsih
;
391 * Create the default params from user defined values..
393 if (iscsi_copy_param_list(&conn
->param_list
,
394 conn
->tpg
->param_list
, 1) < 0) {
395 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
396 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
400 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
403 iscsi_set_keys_to_negotiate(conn
->param_list
, iser
);
405 if (sess
->sess_ops
->SessionType
)
406 return iscsi_set_keys_irrelevant_for_discovery(
409 na
= iscsit_tpg_get_node_attrib(sess
);
412 * Need to send TargetPortalGroupTag back in first login response
413 * on any iSCSI connection where the Initiator provides TargetName.
414 * See 5.3.1. Login Phase Start
416 * In our case, we have already located the struct iscsi_tiqn at this point.
418 if (iscsi_change_param_sprintf(conn
, "TargetPortalGroupTag=%hu", sess
->tpg
->tpgt
))
422 * Workaround for Initiators that have broken connection recovery logic.
424 * "We would really like to get rid of this." Linux-iSCSI.org team
426 if (iscsi_change_param_sprintf(conn
, "ErrorRecoveryLevel=%d", na
->default_erl
))
430 * Set RDMAExtensions=Yes by default for iSER enabled network portals
433 struct iscsi_param
*param
;
434 unsigned long mrdsl
, off
;
437 if (iscsi_change_param_sprintf(conn
, "RDMAExtensions=Yes"))
441 * Make MaxRecvDataSegmentLength PAGE_SIZE aligned for
442 * Immediate Data + Unsolicited Data-OUT if necessary..
444 param
= iscsi_find_param_from_key("MaxRecvDataSegmentLength",
447 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
448 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
451 rc
= kstrtoul(param
->value
, 0, &mrdsl
);
453 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
454 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
457 off
= mrdsl
% PAGE_SIZE
;
461 if (mrdsl
< PAGE_SIZE
)
466 pr_warn("Aligning ISER MaxRecvDataSegmentLength: %lu down"
467 " to PAGE_SIZE\n", mrdsl
);
469 if (iscsi_change_param_sprintf(conn
, "MaxRecvDataSegmentLength=%lu\n", mrdsl
))
472 * ISER currently requires that ImmediateData + Unsolicited
473 * Data be disabled when protection / signature MRs are enabled.
476 if (sess
->se_sess
->sup_prot_ops
&
477 (TARGET_PROT_DOUT_STRIP
| TARGET_PROT_DOUT_PASS
|
478 TARGET_PROT_DOUT_INSERT
)) {
480 if (iscsi_change_param_sprintf(conn
, "ImmediateData=No"))
483 if (iscsi_change_param_sprintf(conn
, "InitialR2T=Yes"))
486 pr_debug("Forcing ImmediateData=No + InitialR2T=Yes for"
487 " T10-PI enabled ISER session\n");
494 static int iscsi_login_non_zero_tsih_s1(
495 struct iscsi_conn
*conn
,
498 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
500 iscsi_login_set_conn_values(NULL
, conn
, pdu
->cid
);
505 * Add a new connection to an existing session.
507 static int iscsi_login_non_zero_tsih_s2(
508 struct iscsi_conn
*conn
,
511 struct iscsi_portal_group
*tpg
= conn
->tpg
;
512 struct iscsi_session
*sess
= NULL
, *sess_p
= NULL
;
513 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
514 struct se_session
*se_sess
, *se_sess_tmp
;
515 struct iscsi_login_req
*pdu
= (struct iscsi_login_req
*)buf
;
518 spin_lock_bh(&se_tpg
->session_lock
);
519 list_for_each_entry_safe(se_sess
, se_sess_tmp
, &se_tpg
->tpg_sess_list
,
522 sess_p
= (struct iscsi_session
*)se_sess
->fabric_sess_ptr
;
523 if (atomic_read(&sess_p
->session_fall_back_to_erl0
) ||
524 atomic_read(&sess_p
->session_logout
) ||
525 (sess_p
->time2retain_timer_flags
& ISCSI_TF_EXPIRED
))
527 if (!memcmp(sess_p
->isid
, pdu
->isid
, 6) &&
528 (sess_p
->tsih
== be16_to_cpu(pdu
->tsih
))) {
529 iscsit_inc_session_usage_count(sess_p
);
530 iscsit_stop_time2retain_timer(sess_p
);
535 spin_unlock_bh(&se_tpg
->session_lock
);
538 * If the Time2Retain handler has expired, the session is already gone.
541 pr_err("Initiator attempting to add a connection to"
542 " a non-existent session, rejecting iSCSI Login.\n");
543 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
544 ISCSI_LOGIN_STATUS_NO_SESSION
);
549 * Stop the Time2Retain timer if this is a failed session, we restart
550 * the timer if the login is not successful.
552 spin_lock_bh(&sess
->conn_lock
);
553 if (sess
->session_state
== TARG_SESS_STATE_FAILED
)
554 atomic_set(&sess
->session_continuation
, 1);
555 spin_unlock_bh(&sess
->conn_lock
);
557 iscsi_login_set_conn_values(sess
, conn
, pdu
->cid
);
559 if (iscsi_copy_param_list(&conn
->param_list
,
560 conn
->tpg
->param_list
, 0) < 0) {
561 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
562 ISCSI_LOGIN_STATUS_NO_RESOURCES
);
566 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
569 iscsi_set_keys_to_negotiate(conn
->param_list
, iser
);
571 * Need to send TargetPortalGroupTag back in first login response
572 * on any iSCSI connection where the Initiator provides TargetName.
573 * See 5.3.1. Login Phase Start
575 * In our case, we have already located the struct iscsi_tiqn at this point.
577 if (iscsi_change_param_sprintf(conn
, "TargetPortalGroupTag=%hu", sess
->tpg
->tpgt
))
583 int iscsi_login_post_auth_non_zero_tsih(
584 struct iscsi_conn
*conn
,
588 struct iscsi_conn
*conn_ptr
= NULL
;
589 struct iscsi_conn_recovery
*cr
= NULL
;
590 struct iscsi_session
*sess
= conn
->sess
;
593 * By following item 5 in the login table, if we have found
594 * an existing ISID and a valid/existing TSIH and an existing
595 * CID we do connection reinstatement. Currently we dont not
596 * support it so we send back an non-zero status class to the
597 * initiator and release the new connection.
599 conn_ptr
= iscsit_get_conn_from_cid_rcfr(sess
, cid
);
601 pr_err("Connection exists with CID %hu for %s,"
602 " performing connection reinstatement.\n",
603 conn_ptr
->cid
, sess
->sess_ops
->InitiatorName
);
605 iscsit_connection_reinstatement_rcfr(conn_ptr
);
606 iscsit_dec_conn_usage_count(conn_ptr
);
610 * Check for any connection recovery entires containing CID.
611 * We use the original ExpStatSN sent in the first login request
612 * to acknowledge commands for the failed connection.
614 * Also note that an explict logout may have already been sent,
615 * but the response may not be sent due to additional connection
618 if (sess
->sess_ops
->ErrorRecoveryLevel
== 2) {
619 cr
= iscsit_get_inactive_connection_recovery_entry(
622 pr_debug("Performing implicit logout"
623 " for connection recovery on CID: %hu\n",
625 iscsit_discard_cr_cmds_by_expstatsn(cr
, exp_statsn
);
630 * Else we follow item 4 from the login table in that we have
631 * found an existing ISID and a valid/existing TSIH and a new
632 * CID we go ahead and continue to add a new connection to the
635 pr_debug("Adding CID %hu to existing session for %s.\n",
636 cid
, sess
->sess_ops
->InitiatorName
);
638 if ((atomic_read(&sess
->nconn
) + 1) > sess
->sess_ops
->MaxConnections
) {
639 pr_err("Adding additional connection to this session"
640 " would exceed MaxConnections %d, login failed.\n",
641 sess
->sess_ops
->MaxConnections
);
642 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
643 ISCSI_LOGIN_STATUS_ISID_ERROR
);
650 static void iscsi_post_login_start_timers(struct iscsi_conn
*conn
)
652 struct iscsi_session
*sess
= conn
->sess
;
654 * FIXME: Unsolicited NopIN support for ISER
656 if (conn
->conn_transport
->transport_type
== ISCSI_INFINIBAND
)
659 if (!sess
->sess_ops
->SessionType
)
660 iscsit_start_nopin_timer(conn
);
663 int iscsit_start_kthreads(struct iscsi_conn
*conn
)
667 spin_lock(&iscsit_global
->ts_bitmap_lock
);
668 conn
->bitmap_id
= bitmap_find_free_region(iscsit_global
->ts_bitmap
,
669 ISCSIT_BITMAP_BITS
, get_order(1));
670 spin_unlock(&iscsit_global
->ts_bitmap_lock
);
672 if (conn
->bitmap_id
< 0) {
673 pr_err("bitmap_find_free_region() failed for"
674 " iscsit_start_kthreads()\n");
678 conn
->tx_thread
= kthread_run(iscsi_target_tx_thread
, conn
,
679 "%s", ISCSI_TX_THREAD_NAME
);
680 if (IS_ERR(conn
->tx_thread
)) {
681 pr_err("Unable to start iscsi_target_tx_thread\n");
682 ret
= PTR_ERR(conn
->tx_thread
);
685 conn
->tx_thread_active
= true;
687 conn
->rx_thread
= kthread_run(iscsi_target_rx_thread
, conn
,
688 "%s", ISCSI_RX_THREAD_NAME
);
689 if (IS_ERR(conn
->rx_thread
)) {
690 pr_err("Unable to start iscsi_target_rx_thread\n");
691 ret
= PTR_ERR(conn
->rx_thread
);
694 conn
->rx_thread_active
= true;
698 send_sig(SIGINT
, conn
->tx_thread
, 1);
699 kthread_stop(conn
->tx_thread
);
700 conn
->tx_thread_active
= false;
702 spin_lock(&iscsit_global
->ts_bitmap_lock
);
703 bitmap_release_region(iscsit_global
->ts_bitmap
, conn
->bitmap_id
,
705 spin_unlock(&iscsit_global
->ts_bitmap_lock
);
709 void iscsi_post_login_handler(
711 struct iscsi_conn
*conn
,
715 struct iscsi_session
*sess
= conn
->sess
;
716 struct se_session
*se_sess
= sess
->se_sess
;
717 struct iscsi_portal_group
*tpg
= sess
->tpg
;
718 struct se_portal_group
*se_tpg
= &tpg
->tpg_se_tpg
;
720 iscsit_inc_conn_usage_count(conn
);
722 iscsit_collect_login_stats(conn
, ISCSI_STATUS_CLS_SUCCESS
,
723 ISCSI_LOGIN_STATUS_ACCEPT
);
725 pr_debug("Moving to TARG_CONN_STATE_LOGGED_IN.\n");
726 conn
->conn_state
= TARG_CONN_STATE_LOGGED_IN
;
728 iscsi_set_connection_parameters(conn
->conn_ops
, conn
->param_list
);
730 * SCSI Initiator -> SCSI Target Port Mapping
733 iscsi_set_session_parameters(sess
->sess_ops
,
734 conn
->param_list
, 0);
735 iscsi_release_param_list(conn
->param_list
);
736 conn
->param_list
= NULL
;
738 spin_lock_bh(&sess
->conn_lock
);
739 atomic_set(&sess
->session_continuation
, 0);
740 if (sess
->session_state
== TARG_SESS_STATE_FAILED
) {
742 " TARG_SESS_STATE_LOGGED_IN.\n");
743 sess
->session_state
= TARG_SESS_STATE_LOGGED_IN
;
747 pr_debug("iSCSI Login successful on CID: %hu from %pISpc to"
748 " %pISpc,%hu\n", conn
->cid
, &conn
->login_sockaddr
,
749 &conn
->local_sockaddr
, tpg
->tpgt
);
751 list_add_tail(&conn
->conn_list
, &sess
->sess_conn_list
);
752 atomic_inc(&sess
->nconn
);
753 pr_debug("Incremented iSCSI Connection count to %hu"
754 " from node: %s\n", atomic_read(&sess
->nconn
),
755 sess
->sess_ops
->InitiatorName
);
756 spin_unlock_bh(&sess
->conn_lock
);
758 iscsi_post_login_start_timers(conn
);
760 * Determine CPU mask to ensure connection's RX and TX kthreads
761 * are scheduled on the same CPU.
763 iscsit_thread_get_cpumask(conn
);
764 conn
->conn_rx_reset_cpumask
= 1;
765 conn
->conn_tx_reset_cpumask
= 1;
767 * Wakeup the sleeping iscsi_target_rx_thread() now that
768 * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state.
770 complete(&conn
->rx_login_comp
);
771 iscsit_dec_conn_usage_count(conn
);
774 spin_lock_bh(&se_tpg
->session_lock
);
775 iscsit_stop_time2retain_timer(sess
);
776 spin_unlock_bh(&se_tpg
->session_lock
);
778 iscsit_dec_session_usage_count(sess
);
782 iscsi_set_session_parameters(sess
->sess_ops
, conn
->param_list
, 1);
783 iscsi_release_param_list(conn
->param_list
);
784 conn
->param_list
= NULL
;
786 iscsit_determine_maxcmdsn(sess
);
788 spin_lock_bh(&se_tpg
->session_lock
);
789 __transport_register_session(&sess
->tpg
->tpg_se_tpg
,
790 se_sess
->se_node_acl
, se_sess
, sess
);
791 pr_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n");
792 sess
->session_state
= TARG_SESS_STATE_LOGGED_IN
;
794 pr_debug("iSCSI Login successful on CID: %hu from %pISpc to %pISpc,%hu\n",
795 conn
->cid
, &conn
->login_sockaddr
, &conn
->local_sockaddr
,
798 spin_lock_bh(&sess
->conn_lock
);
799 list_add_tail(&conn
->conn_list
, &sess
->sess_conn_list
);
800 atomic_inc(&sess
->nconn
);
801 pr_debug("Incremented iSCSI Connection count to %hu from node:"
802 " %s\n", atomic_read(&sess
->nconn
),
803 sess
->sess_ops
->InitiatorName
);
804 spin_unlock_bh(&sess
->conn_lock
);
806 sess
->sid
= tpg
->sid
++;
808 sess
->sid
= tpg
->sid
++;
809 pr_debug("Established iSCSI session from node: %s\n",
810 sess
->sess_ops
->InitiatorName
);
814 tpg
->tpg_tiqn
->tiqn_nsessions
++;
816 pr_debug("Incremented number of active iSCSI sessions to %u on"
817 " iSCSI Target Portal Group: %hu\n", tpg
->nsessions
, tpg
->tpgt
);
818 spin_unlock_bh(&se_tpg
->session_lock
);
820 iscsi_post_login_start_timers(conn
);
822 * Determine CPU mask to ensure connection's RX and TX kthreads
823 * are scheduled on the same CPU.
825 iscsit_thread_get_cpumask(conn
);
826 conn
->conn_rx_reset_cpumask
= 1;
827 conn
->conn_tx_reset_cpumask
= 1;
829 * Wakeup the sleeping iscsi_target_rx_thread() now that
830 * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state.
832 complete(&conn
->rx_login_comp
);
833 iscsit_dec_conn_usage_count(conn
);
836 static void iscsi_handle_login_thread_timeout(unsigned long data
)
838 struct iscsi_np
*np
= (struct iscsi_np
*) data
;
840 spin_lock_bh(&np
->np_thread_lock
);
841 pr_err("iSCSI Login timeout on Network Portal %pISpc\n",
844 if (np
->np_login_timer_flags
& ISCSI_TF_STOP
) {
845 spin_unlock_bh(&np
->np_thread_lock
);
850 send_sig(SIGINT
, np
->np_thread
, 1);
852 np
->np_login_timer_flags
&= ~ISCSI_TF_RUNNING
;
853 spin_unlock_bh(&np
->np_thread_lock
);
856 static void iscsi_start_login_thread_timer(struct iscsi_np
*np
)
859 * This used the TA_LOGIN_TIMEOUT constant because at this
860 * point we do not have access to ISCSI_TPG_ATTRIB(tpg)->login_timeout
862 spin_lock_bh(&np
->np_thread_lock
);
863 init_timer(&np
->np_login_timer
);
864 np
->np_login_timer
.expires
= (get_jiffies_64() + TA_LOGIN_TIMEOUT
* HZ
);
865 np
->np_login_timer
.data
= (unsigned long)np
;
866 np
->np_login_timer
.function
= iscsi_handle_login_thread_timeout
;
867 np
->np_login_timer_flags
&= ~ISCSI_TF_STOP
;
868 np
->np_login_timer_flags
|= ISCSI_TF_RUNNING
;
869 add_timer(&np
->np_login_timer
);
871 pr_debug("Added timeout timer to iSCSI login request for"
872 " %u seconds.\n", TA_LOGIN_TIMEOUT
);
873 spin_unlock_bh(&np
->np_thread_lock
);
876 static void iscsi_stop_login_thread_timer(struct iscsi_np
*np
)
878 spin_lock_bh(&np
->np_thread_lock
);
879 if (!(np
->np_login_timer_flags
& ISCSI_TF_RUNNING
)) {
880 spin_unlock_bh(&np
->np_thread_lock
);
883 np
->np_login_timer_flags
|= ISCSI_TF_STOP
;
884 spin_unlock_bh(&np
->np_thread_lock
);
886 del_timer_sync(&np
->np_login_timer
);
888 spin_lock_bh(&np
->np_thread_lock
);
889 np
->np_login_timer_flags
&= ~ISCSI_TF_RUNNING
;
890 spin_unlock_bh(&np
->np_thread_lock
);
895 struct sockaddr_storage
*sockaddr
)
897 struct socket
*sock
= NULL
;
898 int backlog
= ISCSIT_TCP_BACKLOG
, ret
, opt
= 0, len
;
900 switch (np
->np_network_transport
) {
902 np
->np_ip_proto
= IPPROTO_TCP
;
903 np
->np_sock_type
= SOCK_STREAM
;
906 np
->np_ip_proto
= IPPROTO_SCTP
;
907 np
->np_sock_type
= SOCK_STREAM
;
910 np
->np_ip_proto
= IPPROTO_SCTP
;
911 np
->np_sock_type
= SOCK_SEQPACKET
;
914 pr_err("Unsupported network_transport: %d\n",
915 np
->np_network_transport
);
919 np
->np_ip_proto
= IPPROTO_TCP
;
920 np
->np_sock_type
= SOCK_STREAM
;
922 ret
= sock_create(sockaddr
->ss_family
, np
->np_sock_type
,
923 np
->np_ip_proto
, &sock
);
925 pr_err("sock_create() failed.\n");
928 np
->np_socket
= sock
;
930 * Setup the np->np_sockaddr from the passed sockaddr setup
931 * in iscsi_target_configfs.c code..
933 memcpy(&np
->np_sockaddr
, sockaddr
,
934 sizeof(struct sockaddr_storage
));
936 if (sockaddr
->ss_family
== AF_INET6
)
937 len
= sizeof(struct sockaddr_in6
);
939 len
= sizeof(struct sockaddr_in
);
941 * Set SO_REUSEADDR, and disable Nagel Algorithm with TCP_NODELAY.
943 /* FIXME: Someone please explain why this is endian-safe */
945 if (np
->np_network_transport
== ISCSI_TCP
) {
946 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_NODELAY
,
947 (char *)&opt
, sizeof(opt
));
949 pr_err("kernel_setsockopt() for TCP_NODELAY"
950 " failed: %d\n", ret
);
955 /* FIXME: Someone please explain why this is endian-safe */
956 ret
= kernel_setsockopt(sock
, SOL_SOCKET
, SO_REUSEADDR
,
957 (char *)&opt
, sizeof(opt
));
959 pr_err("kernel_setsockopt() for SO_REUSEADDR"
964 ret
= kernel_setsockopt(sock
, IPPROTO_IP
, IP_FREEBIND
,
965 (char *)&opt
, sizeof(opt
));
967 pr_err("kernel_setsockopt() for IP_FREEBIND"
972 ret
= kernel_bind(sock
, (struct sockaddr
*)&np
->np_sockaddr
, len
);
974 pr_err("kernel_bind() failed: %d\n", ret
);
978 ret
= kernel_listen(sock
, backlog
);
980 pr_err("kernel_listen() failed: %d\n", ret
);
986 np
->np_socket
= NULL
;
991 int iscsi_target_setup_login_socket(
993 struct sockaddr_storage
*sockaddr
)
995 struct iscsit_transport
*t
;
998 t
= iscsit_get_transport(np
->np_network_transport
);
1002 rc
= t
->iscsit_setup_np(np
, sockaddr
);
1004 iscsit_put_transport(t
);
1008 np
->np_transport
= t
;
1013 int iscsit_accept_np(struct iscsi_np
*np
, struct iscsi_conn
*conn
)
1015 struct socket
*new_sock
, *sock
= np
->np_socket
;
1016 struct sockaddr_in sock_in
;
1017 struct sockaddr_in6 sock_in6
;
1020 rc
= kernel_accept(sock
, &new_sock
, 0);
1024 conn
->sock
= new_sock
;
1025 conn
->login_family
= np
->np_sockaddr
.ss_family
;
1027 if (np
->np_sockaddr
.ss_family
== AF_INET6
) {
1028 memset(&sock_in6
, 0, sizeof(struct sockaddr_in6
));
1030 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1031 (struct sockaddr
*)&sock_in6
, &err
, 1);
1033 if (!ipv6_addr_v4mapped(&sock_in6
.sin6_addr
)) {
1034 memcpy(&conn
->login_sockaddr
, &sock_in6
, sizeof(sock_in6
));
1036 /* Pretend to be an ipv4 socket */
1037 sock_in
.sin_family
= AF_INET
;
1038 sock_in
.sin_port
= sock_in6
.sin6_port
;
1039 memcpy(&sock_in
.sin_addr
, &sock_in6
.sin6_addr
.s6_addr32
[3], 4);
1040 memcpy(&conn
->login_sockaddr
, &sock_in
, sizeof(sock_in
));
1044 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1045 (struct sockaddr
*)&sock_in6
, &err
, 0);
1047 if (!ipv6_addr_v4mapped(&sock_in6
.sin6_addr
)) {
1048 memcpy(&conn
->local_sockaddr
, &sock_in6
, sizeof(sock_in6
));
1050 /* Pretend to be an ipv4 socket */
1051 sock_in
.sin_family
= AF_INET
;
1052 sock_in
.sin_port
= sock_in6
.sin6_port
;
1053 memcpy(&sock_in
.sin_addr
, &sock_in6
.sin6_addr
.s6_addr32
[3], 4);
1054 memcpy(&conn
->local_sockaddr
, &sock_in
, sizeof(sock_in
));
1058 memset(&sock_in
, 0, sizeof(struct sockaddr_in
));
1060 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1061 (struct sockaddr
*)&sock_in
, &err
, 1);
1063 memcpy(&conn
->login_sockaddr
, &sock_in
, sizeof(sock_in
));
1065 rc
= conn
->sock
->ops
->getname(conn
->sock
,
1066 (struct sockaddr
*)&sock_in
, &err
, 0);
1068 memcpy(&conn
->local_sockaddr
, &sock_in
, sizeof(sock_in
));
1074 int iscsit_get_login_rx(struct iscsi_conn
*conn
, struct iscsi_login
*login
)
1076 struct iscsi_login_req
*login_req
;
1077 u32 padding
= 0, payload_length
;
1079 if (iscsi_login_rx_data(conn
, login
->req
, ISCSI_HDR_LEN
) < 0)
1082 login_req
= (struct iscsi_login_req
*)login
->req
;
1083 payload_length
= ntoh24(login_req
->dlength
);
1084 padding
= ((-payload_length
) & 3);
1086 pr_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x,"
1087 " CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
1088 login_req
->flags
, login_req
->itt
, login_req
->cmdsn
,
1089 login_req
->exp_statsn
, login_req
->cid
, payload_length
);
1091 * Setup the initial iscsi_login values from the leading
1092 * login request PDU.
1094 if (login
->first_request
) {
1095 login_req
= (struct iscsi_login_req
*)login
->req
;
1096 login
->leading_connection
= (!login_req
->tsih
) ? 1 : 0;
1097 login
->current_stage
= ISCSI_LOGIN_CURRENT_STAGE(login_req
->flags
);
1098 login
->version_min
= login_req
->min_version
;
1099 login
->version_max
= login_req
->max_version
;
1100 memcpy(login
->isid
, login_req
->isid
, 6);
1101 login
->cmd_sn
= be32_to_cpu(login_req
->cmdsn
);
1102 login
->init_task_tag
= login_req
->itt
;
1103 login
->initial_exp_statsn
= be32_to_cpu(login_req
->exp_statsn
);
1104 login
->cid
= be16_to_cpu(login_req
->cid
);
1105 login
->tsih
= be16_to_cpu(login_req
->tsih
);
1108 if (iscsi_target_check_login_request(conn
, login
) < 0)
1111 memset(login
->req_buf
, 0, MAX_KEY_VALUE_PAIRS
);
1112 if (iscsi_login_rx_data(conn
, login
->req_buf
,
1113 payload_length
+ padding
) < 0)
1119 int iscsit_put_login_tx(struct iscsi_conn
*conn
, struct iscsi_login
*login
,
1122 if (iscsi_login_tx_data(conn
, login
->rsp
, login
->rsp_buf
, length
) < 0)
1129 iscsit_conn_set_transport(struct iscsi_conn
*conn
, struct iscsit_transport
*t
)
1134 conn
->conn_transport
= t
;
1138 rc
= try_module_get(t
->owner
);
1140 pr_err("try_module_get() failed for %s\n", t
->name
);
1144 conn
->conn_transport
= t
;
1148 void iscsi_target_login_sess_out(struct iscsi_conn
*conn
,
1149 struct iscsi_np
*np
, bool zero_tsih
, bool new_sess
)
1154 pr_err("iSCSI Login negotiation failed.\n");
1155 iscsit_collect_login_stats(conn
, ISCSI_STATUS_CLS_INITIATOR_ERR
,
1156 ISCSI_LOGIN_STATUS_INIT_ERR
);
1157 if (!zero_tsih
|| !conn
->sess
)
1159 if (conn
->sess
->se_sess
)
1160 transport_free_session(conn
->sess
->se_sess
);
1161 if (conn
->sess
->session_index
!= 0) {
1162 spin_lock_bh(&sess_idr_lock
);
1163 idr_remove(&sess_idr
, conn
->sess
->session_index
);
1164 spin_unlock_bh(&sess_idr_lock
);
1166 kfree(conn
->sess
->sess_ops
);
1171 iscsi_stop_login_thread_timer(np
);
1173 * If login negotiation fails check if the Time2Retain timer
1174 * needs to be restarted.
1176 if (!zero_tsih
&& conn
->sess
) {
1177 spin_lock_bh(&conn
->sess
->conn_lock
);
1178 if (conn
->sess
->session_state
== TARG_SESS_STATE_FAILED
) {
1179 struct se_portal_group
*se_tpg
=
1180 &conn
->tpg
->tpg_se_tpg
;
1182 atomic_set(&conn
->sess
->session_continuation
, 0);
1183 spin_unlock_bh(&conn
->sess
->conn_lock
);
1184 spin_lock_bh(&se_tpg
->session_lock
);
1185 iscsit_start_time2retain_handler(conn
->sess
);
1186 spin_unlock_bh(&se_tpg
->session_lock
);
1188 spin_unlock_bh(&conn
->sess
->conn_lock
);
1189 iscsit_dec_session_usage_count(conn
->sess
);
1192 ahash_request_free(conn
->conn_tx_hash
);
1193 if (conn
->conn_rx_hash
) {
1194 struct crypto_ahash
*tfm
;
1196 tfm
= crypto_ahash_reqtfm(conn
->conn_rx_hash
);
1197 ahash_request_free(conn
->conn_rx_hash
);
1198 crypto_free_ahash(tfm
);
1201 free_cpumask_var(conn
->conn_cpumask
);
1203 kfree(conn
->conn_ops
);
1205 if (conn
->param_list
) {
1206 iscsi_release_param_list(conn
->param_list
);
1207 conn
->param_list
= NULL
;
1209 iscsi_target_nego_release(conn
);
1212 sock_release(conn
->sock
);
1216 if (conn
->conn_transport
->iscsit_wait_conn
)
1217 conn
->conn_transport
->iscsit_wait_conn(conn
);
1219 if (conn
->conn_transport
->iscsit_free_conn
)
1220 conn
->conn_transport
->iscsit_free_conn(conn
);
1222 iscsit_put_transport(conn
->conn_transport
);
1226 static int __iscsi_target_login_thread(struct iscsi_np
*np
)
1228 u8
*buffer
, zero_tsih
= 0;
1230 struct iscsi_conn
*conn
= NULL
;
1231 struct iscsi_login
*login
;
1232 struct iscsi_portal_group
*tpg
= NULL
;
1233 struct iscsi_login_req
*pdu
;
1234 struct iscsi_tpg_np
*tpg_np
;
1235 bool new_sess
= false;
1237 flush_signals(current
);
1239 spin_lock_bh(&np
->np_thread_lock
);
1240 if (np
->np_thread_state
== ISCSI_NP_THREAD_RESET
) {
1241 np
->np_thread_state
= ISCSI_NP_THREAD_ACTIVE
;
1242 complete(&np
->np_restart_comp
);
1243 } else if (np
->np_thread_state
== ISCSI_NP_THREAD_SHUTDOWN
) {
1244 spin_unlock_bh(&np
->np_thread_lock
);
1247 np
->np_thread_state
= ISCSI_NP_THREAD_ACTIVE
;
1249 spin_unlock_bh(&np
->np_thread_lock
);
1251 conn
= kzalloc(sizeof(struct iscsi_conn
), GFP_KERNEL
);
1253 pr_err("Could not allocate memory for"
1254 " new connection\n");
1255 /* Get another socket */
1258 pr_debug("Moving to TARG_CONN_STATE_FREE.\n");
1259 conn
->conn_state
= TARG_CONN_STATE_FREE
;
1261 if (iscsit_conn_set_transport(conn
, np
->np_transport
) < 0) {
1266 rc
= np
->np_transport
->iscsit_accept_np(np
, conn
);
1267 if (rc
== -ENOSYS
) {
1268 complete(&np
->np_restart_comp
);
1269 iscsit_put_transport(conn
->conn_transport
);
1273 } else if (rc
< 0) {
1274 spin_lock_bh(&np
->np_thread_lock
);
1275 if (np
->np_thread_state
== ISCSI_NP_THREAD_RESET
) {
1276 spin_unlock_bh(&np
->np_thread_lock
);
1277 complete(&np
->np_restart_comp
);
1278 iscsit_put_transport(conn
->conn_transport
);
1281 /* Get another socket */
1284 spin_unlock_bh(&np
->np_thread_lock
);
1285 iscsit_put_transport(conn
->conn_transport
);
1291 * Perform the remaining iSCSI connection initialization items..
1293 login
= iscsi_login_init_conn(conn
);
1298 iscsi_start_login_thread_timer(np
);
1300 pr_debug("Moving to TARG_CONN_STATE_XPT_UP.\n");
1301 conn
->conn_state
= TARG_CONN_STATE_XPT_UP
;
1303 * This will process the first login request + payload..
1305 rc
= np
->np_transport
->iscsit_get_login_rx(conn
, login
);
1311 buffer
= &login
->req
[0];
1312 pdu
= (struct iscsi_login_req
*)buffer
;
1314 * Used by iscsit_tx_login_rsp() for Login Resonses PDUs
1315 * when Status-Class != 0.
1317 conn
->login_itt
= pdu
->itt
;
1319 spin_lock_bh(&np
->np_thread_lock
);
1320 if (np
->np_thread_state
!= ISCSI_NP_THREAD_ACTIVE
) {
1321 spin_unlock_bh(&np
->np_thread_lock
);
1322 pr_err("iSCSI Network Portal on %pISpc currently not"
1323 " active.\n", &np
->np_sockaddr
);
1324 iscsit_tx_login_rsp(conn
, ISCSI_STATUS_CLS_TARGET_ERR
,
1325 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE
);
1328 spin_unlock_bh(&np
->np_thread_lock
);
1330 conn
->network_transport
= np
->np_network_transport
;
1332 pr_debug("Received iSCSI login request from %pISpc on %s Network"
1333 " Portal %pISpc\n", &conn
->login_sockaddr
, np
->np_transport
->name
,
1334 &conn
->local_sockaddr
);
1336 pr_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n");
1337 conn
->conn_state
= TARG_CONN_STATE_IN_LOGIN
;
1339 if (iscsi_login_check_initiator_version(conn
, pdu
->max_version
,
1340 pdu
->min_version
) < 0)
1343 zero_tsih
= (pdu
->tsih
== 0x0000);
1346 * This is the leading connection of a new session.
1347 * We wait until after authentication to check for
1348 * session reinstatement.
1350 if (iscsi_login_zero_tsih_s1(conn
, buffer
) < 0)
1354 * Add a new connection to an existing session.
1355 * We check for a non-existant session in
1356 * iscsi_login_non_zero_tsih_s2() below based
1357 * on ISID/TSIH, but wait until after authentication
1358 * to check for connection reinstatement, etc.
1360 if (iscsi_login_non_zero_tsih_s1(conn
, buffer
) < 0)
1364 * SessionType: Discovery
1366 * Locates Default Portal
1368 * SessionType: Normal
1370 * Locates Target Portal from NP -> Target IQN
1372 rc
= iscsi_target_locate_portal(np
, conn
, login
);
1377 login
->zero_tsih
= zero_tsih
;
1380 conn
->sess
->se_sess
->sup_prot_ops
=
1381 conn
->conn_transport
->iscsit_get_sup_prot_ops(conn
);
1385 pr_err("Unable to locate struct iscsi_conn->tpg\n");
1390 if (iscsi_login_zero_tsih_s2(conn
) < 0)
1393 if (iscsi_login_non_zero_tsih_s2(conn
, buffer
) < 0)
1397 if (conn
->conn_transport
->iscsit_validate_params
) {
1398 ret
= conn
->conn_transport
->iscsit_validate_params(conn
);
1407 ret
= iscsi_target_start_negotiation(login
, conn
);
1411 iscsi_stop_login_thread_timer(np
);
1414 tpg_np
= conn
->tpg_np
;
1416 iscsi_post_login_handler(np
, conn
, zero_tsih
);
1417 iscsit_deaccess_np(np
, tpg
, tpg_np
);
1422 /* Get another socket */
1428 tpg_np
= conn
->tpg_np
;
1429 iscsi_target_login_sess_out(conn
, np
, zero_tsih
, new_sess
);
1433 iscsit_deaccess_np(np
, tpg
, tpg_np
);
1442 iscsi_stop_login_thread_timer(np
);
1443 spin_lock_bh(&np
->np_thread_lock
);
1444 np
->np_thread_state
= ISCSI_NP_THREAD_EXIT
;
1445 spin_unlock_bh(&np
->np_thread_lock
);
1450 int iscsi_target_login_thread(void *arg
)
1452 struct iscsi_np
*np
= arg
;
1455 allow_signal(SIGINT
);
1458 ret
= __iscsi_target_login_thread(np
);
1460 * We break and exit here unless another sock_accept() call