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