1/******************************************************************************* 2 * This file contains the login functions used by the iSCSI Target driver. 3 * 4 * (c) Copyright 2007-2013 Datera, Inc. 5 * 6 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org> 7 * 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. 12 * 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 ******************************************************************************/ 18 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> 26 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" 38 39#include <target/iscsi/iscsi_transport.h> 40 41static struct iscsi_login *iscsi_login_init_conn(struct iscsi_conn *conn) 42{ 43 struct iscsi_login *login; 44 45 login = kzalloc(sizeof(struct iscsi_login), GFP_KERNEL); 46 if (!login) { 47 pr_err("Unable to allocate memory for struct iscsi_login.\n"); 48 return NULL; 49 } 50 conn->login = login; 51 login->conn = conn; 52 login->first_request = 1; 53 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"); 57 goto out_login; 58 } 59 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"); 63 goto out_req_buf; 64 } 65 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"); 70 goto out_rsp_buf; 71 } 72 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 init_completion(&conn->rx_login_comp); 86 spin_lock_init(&conn->cmd_lock); 87 spin_lock_init(&conn->conn_usage_lock); 88 spin_lock_init(&conn->immed_queue_lock); 89 spin_lock_init(&conn->nopin_timer_lock); 90 spin_lock_init(&conn->response_queue_lock); 91 spin_lock_init(&conn->state_lock); 92 93 if (!zalloc_cpumask_var(&conn->conn_cpumask, GFP_KERNEL)) { 94 pr_err("Unable to allocate conn->conn_cpumask\n"); 95 goto out_conn_ops; 96 } 97 conn->conn_login = login; 98 99 return login; 100 101out_conn_ops: 102 kfree(conn->conn_ops); 103out_rsp_buf: 104 kfree(login->rsp_buf); 105out_req_buf: 106 kfree(login->req_buf); 107out_login: 108 kfree(login); 109 return NULL; 110} 111 112/* 113 * Used by iscsi_target_nego.c:iscsi_target_locate_portal() to setup 114 * per struct iscsi_conn libcrypto contexts for crc32c and crc32-intel 115 */ 116int iscsi_login_setup_crypto(struct iscsi_conn *conn) 117{ 118 /* 119 * Setup slicing by CRC32C algorithm for RX and TX libcrypto contexts 120 * which will default to crc32c_intel.ko for cpu_has_xmm4_2, or fallback 121 * to software 1x8 byte slicing from crc32c.ko 122 */ 123 conn->conn_rx_hash.flags = 0; 124 conn->conn_rx_hash.tfm = crypto_alloc_hash("crc32c", 0, 125 CRYPTO_ALG_ASYNC); 126 if (IS_ERR(conn->conn_rx_hash.tfm)) { 127 pr_err("crypto_alloc_hash() failed for conn_rx_tfm\n"); 128 return -ENOMEM; 129 } 130 131 conn->conn_tx_hash.flags = 0; 132 conn->conn_tx_hash.tfm = crypto_alloc_hash("crc32c", 0, 133 CRYPTO_ALG_ASYNC); 134 if (IS_ERR(conn->conn_tx_hash.tfm)) { 135 pr_err("crypto_alloc_hash() failed for conn_tx_tfm\n"); 136 crypto_free_hash(conn->conn_rx_hash.tfm); 137 return -ENOMEM; 138 } 139 140 return 0; 141} 142 143static int iscsi_login_check_initiator_version( 144 struct iscsi_conn *conn, 145 u8 version_max, 146 u8 version_min) 147{ 148 if ((version_max != 0x00) || (version_min != 0x00)) { 149 pr_err("Unsupported iSCSI IETF Pre-RFC Revision," 150 " version Min/Max 0x%02x/0x%02x, rejecting login.\n", 151 version_min, version_max); 152 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 153 ISCSI_LOGIN_STATUS_NO_VERSION); 154 return -1; 155 } 156 157 return 0; 158} 159 160int iscsi_check_for_session_reinstatement(struct iscsi_conn *conn) 161{ 162 int sessiontype; 163 struct iscsi_param *initiatorname_param = NULL, *sessiontype_param = NULL; 164 struct iscsi_portal_group *tpg = conn->tpg; 165 struct iscsi_session *sess = NULL, *sess_p = NULL; 166 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 167 struct se_session *se_sess, *se_sess_tmp; 168 169 initiatorname_param = iscsi_find_param_from_key( 170 INITIATORNAME, conn->param_list); 171 sessiontype_param = iscsi_find_param_from_key( 172 SESSIONTYPE, conn->param_list); 173 if (!initiatorname_param || !sessiontype_param) { 174 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 175 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 176 return -1; 177 } 178 179 sessiontype = (strncmp(sessiontype_param->value, NORMAL, 6)) ? 1 : 0; 180 181 spin_lock_bh(&se_tpg->session_lock); 182 list_for_each_entry_safe(se_sess, se_sess_tmp, &se_tpg->tpg_sess_list, 183 sess_list) { 184 185 sess_p = se_sess->fabric_sess_ptr; 186 spin_lock(&sess_p->conn_lock); 187 if (atomic_read(&sess_p->session_fall_back_to_erl0) || 188 atomic_read(&sess_p->session_logout) || 189 (sess_p->time2retain_timer_flags & ISCSI_TF_EXPIRED)) { 190 spin_unlock(&sess_p->conn_lock); 191 continue; 192 } 193 if (!memcmp(sess_p->isid, conn->sess->isid, 6) && 194 (!strcmp(sess_p->sess_ops->InitiatorName, 195 initiatorname_param->value) && 196 (sess_p->sess_ops->SessionType == sessiontype))) { 197 atomic_set(&sess_p->session_reinstatement, 1); 198 spin_unlock(&sess_p->conn_lock); 199 iscsit_inc_session_usage_count(sess_p); 200 iscsit_stop_time2retain_timer(sess_p); 201 sess = sess_p; 202 break; 203 } 204 spin_unlock(&sess_p->conn_lock); 205 } 206 spin_unlock_bh(&se_tpg->session_lock); 207 /* 208 * If the Time2Retain handler has expired, the session is already gone. 209 */ 210 if (!sess) 211 return 0; 212 213 pr_debug("%s iSCSI Session SID %u is still active for %s," 214 " preforming session reinstatement.\n", (sessiontype) ? 215 "Discovery" : "Normal", sess->sid, 216 sess->sess_ops->InitiatorName); 217 218 spin_lock_bh(&sess->conn_lock); 219 if (sess->session_state == TARG_SESS_STATE_FAILED) { 220 spin_unlock_bh(&sess->conn_lock); 221 iscsit_dec_session_usage_count(sess); 222 target_put_session(sess->se_sess); 223 return 0; 224 } 225 spin_unlock_bh(&sess->conn_lock); 226 227 iscsit_stop_session(sess, 1, 1); 228 iscsit_dec_session_usage_count(sess); 229 230 target_put_session(sess->se_sess); 231 return 0; 232} 233 234static void iscsi_login_set_conn_values( 235 struct iscsi_session *sess, 236 struct iscsi_conn *conn, 237 __be16 cid) 238{ 239 conn->sess = sess; 240 conn->cid = be16_to_cpu(cid); 241 /* 242 * Generate a random Status sequence number (statsn) for the new 243 * iSCSI connection. 244 */ 245 get_random_bytes(&conn->stat_sn, sizeof(u32)); 246 247 mutex_lock(&auth_id_lock); 248 conn->auth_id = iscsit_global->auth_id++; 249 mutex_unlock(&auth_id_lock); 250} 251 252static __printf(2, 3) int iscsi_change_param_sprintf( 253 struct iscsi_conn *conn, 254 const char *fmt, ...) 255{ 256 va_list args; 257 unsigned char buf[64]; 258 259 memset(buf, 0, sizeof buf); 260 261 va_start(args, fmt); 262 vsnprintf(buf, sizeof buf, fmt, args); 263 va_end(args); 264 265 if (iscsi_change_param_value(buf, conn->param_list, 0) < 0) { 266 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 267 ISCSI_LOGIN_STATUS_NO_RESOURCES); 268 return -1; 269 } 270 271 return 0; 272} 273 274/* 275 * This is the leading connection of a new session, 276 * or session reinstatement. 277 */ 278static int iscsi_login_zero_tsih_s1( 279 struct iscsi_conn *conn, 280 unsigned char *buf) 281{ 282 struct iscsi_session *sess = NULL; 283 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf; 284 int ret; 285 286 sess = kzalloc(sizeof(struct iscsi_session), GFP_KERNEL); 287 if (!sess) { 288 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 289 ISCSI_LOGIN_STATUS_NO_RESOURCES); 290 pr_err("Could not allocate memory for session\n"); 291 return -ENOMEM; 292 } 293 294 iscsi_login_set_conn_values(sess, conn, pdu->cid); 295 sess->init_task_tag = pdu->itt; 296 memcpy(&sess->isid, pdu->isid, 6); 297 sess->exp_cmd_sn = be32_to_cpu(pdu->cmdsn); 298 INIT_LIST_HEAD(&sess->sess_conn_list); 299 INIT_LIST_HEAD(&sess->sess_ooo_cmdsn_list); 300 INIT_LIST_HEAD(&sess->cr_active_list); 301 INIT_LIST_HEAD(&sess->cr_inactive_list); 302 init_completion(&sess->async_msg_comp); 303 init_completion(&sess->reinstatement_comp); 304 init_completion(&sess->session_wait_comp); 305 init_completion(&sess->session_waiting_on_uc_comp); 306 mutex_init(&sess->cmdsn_mutex); 307 spin_lock_init(&sess->conn_lock); 308 spin_lock_init(&sess->cr_a_lock); 309 spin_lock_init(&sess->cr_i_lock); 310 spin_lock_init(&sess->session_usage_lock); 311 spin_lock_init(&sess->ttt_lock); 312 313 idr_preload(GFP_KERNEL); 314 spin_lock_bh(&sess_idr_lock); 315 ret = idr_alloc(&sess_idr, NULL, 0, 0, GFP_NOWAIT); 316 if (ret >= 0) 317 sess->session_index = ret; 318 spin_unlock_bh(&sess_idr_lock); 319 idr_preload_end(); 320 321 if (ret < 0) { 322 pr_err("idr_alloc() for sess_idr failed\n"); 323 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 324 ISCSI_LOGIN_STATUS_NO_RESOURCES); 325 kfree(sess); 326 return -ENOMEM; 327 } 328 329 sess->creation_time = get_jiffies_64(); 330 /* 331 * The FFP CmdSN window values will be allocated from the TPG's 332 * Initiator Node's ACL once the login has been successfully completed. 333 */ 334 sess->max_cmd_sn = be32_to_cpu(pdu->cmdsn); 335 336 sess->sess_ops = kzalloc(sizeof(struct iscsi_sess_ops), GFP_KERNEL); 337 if (!sess->sess_ops) { 338 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 339 ISCSI_LOGIN_STATUS_NO_RESOURCES); 340 pr_err("Unable to allocate memory for" 341 " struct iscsi_sess_ops.\n"); 342 kfree(sess); 343 return -ENOMEM; 344 } 345 346 sess->se_sess = transport_init_session(TARGET_PROT_NORMAL); 347 if (IS_ERR(sess->se_sess)) { 348 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 349 ISCSI_LOGIN_STATUS_NO_RESOURCES); 350 kfree(sess->sess_ops); 351 kfree(sess); 352 return -ENOMEM; 353 } 354 355 return 0; 356} 357 358static int iscsi_login_zero_tsih_s2( 359 struct iscsi_conn *conn) 360{ 361 struct iscsi_node_attrib *na; 362 struct iscsi_session *sess = conn->sess; 363 bool iser = false; 364 365 sess->tpg = conn->tpg; 366 367 /* 368 * Assign a new TPG Session Handle. Note this is protected with 369 * struct iscsi_portal_group->np_login_sem from iscsit_access_np(). 370 */ 371 sess->tsih = ++sess->tpg->ntsih; 372 if (!sess->tsih) 373 sess->tsih = ++sess->tpg->ntsih; 374 375 /* 376 * Create the default params from user defined values.. 377 */ 378 if (iscsi_copy_param_list(&conn->param_list, 379 conn->tpg->param_list, 1) < 0) { 380 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 381 ISCSI_LOGIN_STATUS_NO_RESOURCES); 382 return -1; 383 } 384 385 if (conn->conn_transport->transport_type == ISCSI_INFINIBAND) 386 iser = true; 387 388 iscsi_set_keys_to_negotiate(conn->param_list, iser); 389 390 if (sess->sess_ops->SessionType) 391 return iscsi_set_keys_irrelevant_for_discovery( 392 conn->param_list); 393 394 na = iscsit_tpg_get_node_attrib(sess); 395 396 /* 397 * Need to send TargetPortalGroupTag back in first login response 398 * on any iSCSI connection where the Initiator provides TargetName. 399 * See 5.3.1. Login Phase Start 400 * 401 * In our case, we have already located the struct iscsi_tiqn at this point. 402 */ 403 if (iscsi_change_param_sprintf(conn, "TargetPortalGroupTag=%hu", sess->tpg->tpgt)) 404 return -1; 405 406 /* 407 * Workaround for Initiators that have broken connection recovery logic. 408 * 409 * "We would really like to get rid of this." Linux-iSCSI.org team 410 */ 411 if (iscsi_change_param_sprintf(conn, "ErrorRecoveryLevel=%d", na->default_erl)) 412 return -1; 413 414 if (iscsi_login_disable_FIM_keys(conn->param_list, conn) < 0) 415 return -1; 416 /* 417 * Set RDMAExtensions=Yes by default for iSER enabled network portals 418 */ 419 if (iser) { 420 struct iscsi_param *param; 421 unsigned long mrdsl, off; 422 int rc; 423 424 if (iscsi_change_param_sprintf(conn, "RDMAExtensions=Yes")) 425 return -1; 426 427 /* 428 * Make MaxRecvDataSegmentLength PAGE_SIZE aligned for 429 * Immediate Data + Unsolicitied Data-OUT if necessary.. 430 */ 431 param = iscsi_find_param_from_key("MaxRecvDataSegmentLength", 432 conn->param_list); 433 if (!param) { 434 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 435 ISCSI_LOGIN_STATUS_NO_RESOURCES); 436 return -1; 437 } 438 rc = kstrtoul(param->value, 0, &mrdsl); 439 if (rc < 0) { 440 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 441 ISCSI_LOGIN_STATUS_NO_RESOURCES); 442 return -1; 443 } 444 off = mrdsl % PAGE_SIZE; 445 if (!off) 446 goto check_prot; 447 448 if (mrdsl < PAGE_SIZE) 449 mrdsl = PAGE_SIZE; 450 else 451 mrdsl -= off; 452 453 pr_warn("Aligning ISER MaxRecvDataSegmentLength: %lu down" 454 " to PAGE_SIZE\n", mrdsl); 455 456 if (iscsi_change_param_sprintf(conn, "MaxRecvDataSegmentLength=%lu\n", mrdsl)) 457 return -1; 458 /* 459 * ISER currently requires that ImmediateData + Unsolicited 460 * Data be disabled when protection / signature MRs are enabled. 461 */ 462check_prot: 463 if (sess->se_sess->sup_prot_ops & 464 (TARGET_PROT_DOUT_STRIP | TARGET_PROT_DOUT_PASS | 465 TARGET_PROT_DOUT_INSERT)) { 466 467 if (iscsi_change_param_sprintf(conn, "ImmediateData=No")) 468 return -1; 469 470 if (iscsi_change_param_sprintf(conn, "InitialR2T=Yes")) 471 return -1; 472 473 pr_debug("Forcing ImmediateData=No + InitialR2T=Yes for" 474 " T10-PI enabled ISER session\n"); 475 } 476 } 477 478 return 0; 479} 480 481/* 482 * Remove PSTATE_NEGOTIATE for the four FIM related keys. 483 * The Initiator node will be able to enable FIM by proposing them itself. 484 */ 485int iscsi_login_disable_FIM_keys( 486 struct iscsi_param_list *param_list, 487 struct iscsi_conn *conn) 488{ 489 struct iscsi_param *param; 490 491 param = iscsi_find_param_from_key("OFMarker", param_list); 492 if (!param) { 493 pr_err("iscsi_find_param_from_key() for" 494 " OFMarker failed\n"); 495 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 496 ISCSI_LOGIN_STATUS_NO_RESOURCES); 497 return -1; 498 } 499 param->state &= ~PSTATE_NEGOTIATE; 500 501 param = iscsi_find_param_from_key("OFMarkInt", param_list); 502 if (!param) { 503 pr_err("iscsi_find_param_from_key() for" 504 " IFMarker failed\n"); 505 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 506 ISCSI_LOGIN_STATUS_NO_RESOURCES); 507 return -1; 508 } 509 param->state &= ~PSTATE_NEGOTIATE; 510 511 param = iscsi_find_param_from_key("IFMarker", param_list); 512 if (!param) { 513 pr_err("iscsi_find_param_from_key() for" 514 " IFMarker failed\n"); 515 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 516 ISCSI_LOGIN_STATUS_NO_RESOURCES); 517 return -1; 518 } 519 param->state &= ~PSTATE_NEGOTIATE; 520 521 param = iscsi_find_param_from_key("IFMarkInt", param_list); 522 if (!param) { 523 pr_err("iscsi_find_param_from_key() for" 524 " IFMarker failed\n"); 525 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 526 ISCSI_LOGIN_STATUS_NO_RESOURCES); 527 return -1; 528 } 529 param->state &= ~PSTATE_NEGOTIATE; 530 531 return 0; 532} 533 534static int iscsi_login_non_zero_tsih_s1( 535 struct iscsi_conn *conn, 536 unsigned char *buf) 537{ 538 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf; 539 540 iscsi_login_set_conn_values(NULL, conn, pdu->cid); 541 return 0; 542} 543 544/* 545 * Add a new connection to an existing session. 546 */ 547static int iscsi_login_non_zero_tsih_s2( 548 struct iscsi_conn *conn, 549 unsigned char *buf) 550{ 551 struct iscsi_portal_group *tpg = conn->tpg; 552 struct iscsi_session *sess = NULL, *sess_p = NULL; 553 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 554 struct se_session *se_sess, *se_sess_tmp; 555 struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf; 556 bool iser = false; 557 558 spin_lock_bh(&se_tpg->session_lock); 559 list_for_each_entry_safe(se_sess, se_sess_tmp, &se_tpg->tpg_sess_list, 560 sess_list) { 561 562 sess_p = (struct iscsi_session *)se_sess->fabric_sess_ptr; 563 if (atomic_read(&sess_p->session_fall_back_to_erl0) || 564 atomic_read(&sess_p->session_logout) || 565 (sess_p->time2retain_timer_flags & ISCSI_TF_EXPIRED)) 566 continue; 567 if (!memcmp(sess_p->isid, pdu->isid, 6) && 568 (sess_p->tsih == be16_to_cpu(pdu->tsih))) { 569 iscsit_inc_session_usage_count(sess_p); 570 iscsit_stop_time2retain_timer(sess_p); 571 sess = sess_p; 572 break; 573 } 574 } 575 spin_unlock_bh(&se_tpg->session_lock); 576 577 /* 578 * If the Time2Retain handler has expired, the session is already gone. 579 */ 580 if (!sess) { 581 pr_err("Initiator attempting to add a connection to" 582 " a non-existent session, rejecting iSCSI Login.\n"); 583 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 584 ISCSI_LOGIN_STATUS_NO_SESSION); 585 return -1; 586 } 587 588 /* 589 * Stop the Time2Retain timer if this is a failed session, we restart 590 * the timer if the login is not successful. 591 */ 592 spin_lock_bh(&sess->conn_lock); 593 if (sess->session_state == TARG_SESS_STATE_FAILED) 594 atomic_set(&sess->session_continuation, 1); 595 spin_unlock_bh(&sess->conn_lock); 596 597 iscsi_login_set_conn_values(sess, conn, pdu->cid); 598 599 if (iscsi_copy_param_list(&conn->param_list, 600 conn->tpg->param_list, 0) < 0) { 601 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 602 ISCSI_LOGIN_STATUS_NO_RESOURCES); 603 return -1; 604 } 605 606 if (conn->conn_transport->transport_type == ISCSI_INFINIBAND) 607 iser = true; 608 609 iscsi_set_keys_to_negotiate(conn->param_list, iser); 610 /* 611 * Need to send TargetPortalGroupTag back in first login response 612 * on any iSCSI connection where the Initiator provides TargetName. 613 * See 5.3.1. Login Phase Start 614 * 615 * In our case, we have already located the struct iscsi_tiqn at this point. 616 */ 617 if (iscsi_change_param_sprintf(conn, "TargetPortalGroupTag=%hu", sess->tpg->tpgt)) 618 return -1; 619 620 return iscsi_login_disable_FIM_keys(conn->param_list, conn); 621} 622 623int iscsi_login_post_auth_non_zero_tsih( 624 struct iscsi_conn *conn, 625 u16 cid, 626 u32 exp_statsn) 627{ 628 struct iscsi_conn *conn_ptr = NULL; 629 struct iscsi_conn_recovery *cr = NULL; 630 struct iscsi_session *sess = conn->sess; 631 632 /* 633 * By following item 5 in the login table, if we have found 634 * an existing ISID and a valid/existing TSIH and an existing 635 * CID we do connection reinstatement. Currently we dont not 636 * support it so we send back an non-zero status class to the 637 * initiator and release the new connection. 638 */ 639 conn_ptr = iscsit_get_conn_from_cid_rcfr(sess, cid); 640 if (conn_ptr) { 641 pr_err("Connection exists with CID %hu for %s," 642 " performing connection reinstatement.\n", 643 conn_ptr->cid, sess->sess_ops->InitiatorName); 644 645 iscsit_connection_reinstatement_rcfr(conn_ptr); 646 iscsit_dec_conn_usage_count(conn_ptr); 647 } 648 649 /* 650 * Check for any connection recovery entires containing CID. 651 * We use the original ExpStatSN sent in the first login request 652 * to acknowledge commands for the failed connection. 653 * 654 * Also note that an explict logout may have already been sent, 655 * but the response may not be sent due to additional connection 656 * loss. 657 */ 658 if (sess->sess_ops->ErrorRecoveryLevel == 2) { 659 cr = iscsit_get_inactive_connection_recovery_entry( 660 sess, cid); 661 if (cr) { 662 pr_debug("Performing implicit logout" 663 " for connection recovery on CID: %hu\n", 664 conn->cid); 665 iscsit_discard_cr_cmds_by_expstatsn(cr, exp_statsn); 666 } 667 } 668 669 /* 670 * Else we follow item 4 from the login table in that we have 671 * found an existing ISID and a valid/existing TSIH and a new 672 * CID we go ahead and continue to add a new connection to the 673 * session. 674 */ 675 pr_debug("Adding CID %hu to existing session for %s.\n", 676 cid, sess->sess_ops->InitiatorName); 677 678 if ((atomic_read(&sess->nconn) + 1) > sess->sess_ops->MaxConnections) { 679 pr_err("Adding additional connection to this session" 680 " would exceed MaxConnections %d, login failed.\n", 681 sess->sess_ops->MaxConnections); 682 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 683 ISCSI_LOGIN_STATUS_ISID_ERROR); 684 return -1; 685 } 686 687 return 0; 688} 689 690static void iscsi_post_login_start_timers(struct iscsi_conn *conn) 691{ 692 struct iscsi_session *sess = conn->sess; 693 /* 694 * FIXME: Unsolicitied NopIN support for ISER 695 */ 696 if (conn->conn_transport->transport_type == ISCSI_INFINIBAND) 697 return; 698 699 if (!sess->sess_ops->SessionType) 700 iscsit_start_nopin_timer(conn); 701} 702 703int iscsit_start_kthreads(struct iscsi_conn *conn) 704{ 705 int ret = 0; 706 707 spin_lock(&iscsit_global->ts_bitmap_lock); 708 conn->bitmap_id = bitmap_find_free_region(iscsit_global->ts_bitmap, 709 ISCSIT_BITMAP_BITS, get_order(1)); 710 spin_unlock(&iscsit_global->ts_bitmap_lock); 711 712 if (conn->bitmap_id < 0) { 713 pr_err("bitmap_find_free_region() failed for" 714 " iscsit_start_kthreads()\n"); 715 return -ENOMEM; 716 } 717 718 conn->tx_thread = kthread_run(iscsi_target_tx_thread, conn, 719 "%s", ISCSI_TX_THREAD_NAME); 720 if (IS_ERR(conn->tx_thread)) { 721 pr_err("Unable to start iscsi_target_tx_thread\n"); 722 ret = PTR_ERR(conn->tx_thread); 723 goto out_bitmap; 724 } 725 conn->tx_thread_active = true; 726 727 conn->rx_thread = kthread_run(iscsi_target_rx_thread, conn, 728 "%s", ISCSI_RX_THREAD_NAME); 729 if (IS_ERR(conn->rx_thread)) { 730 pr_err("Unable to start iscsi_target_rx_thread\n"); 731 ret = PTR_ERR(conn->rx_thread); 732 goto out_tx; 733 } 734 conn->rx_thread_active = true; 735 736 return 0; 737out_tx: 738 send_sig(SIGINT, conn->tx_thread, 1); 739 kthread_stop(conn->tx_thread); 740 conn->tx_thread_active = false; 741out_bitmap: 742 spin_lock(&iscsit_global->ts_bitmap_lock); 743 bitmap_release_region(iscsit_global->ts_bitmap, conn->bitmap_id, 744 get_order(1)); 745 spin_unlock(&iscsit_global->ts_bitmap_lock); 746 return ret; 747} 748 749void iscsi_post_login_handler( 750 struct iscsi_np *np, 751 struct iscsi_conn *conn, 752 u8 zero_tsih) 753{ 754 int stop_timer = 0; 755 struct iscsi_session *sess = conn->sess; 756 struct se_session *se_sess = sess->se_sess; 757 struct iscsi_portal_group *tpg = sess->tpg; 758 struct se_portal_group *se_tpg = &tpg->tpg_se_tpg; 759 760 iscsit_inc_conn_usage_count(conn); 761 762 iscsit_collect_login_stats(conn, ISCSI_STATUS_CLS_SUCCESS, 763 ISCSI_LOGIN_STATUS_ACCEPT); 764 765 pr_debug("Moving to TARG_CONN_STATE_LOGGED_IN.\n"); 766 conn->conn_state = TARG_CONN_STATE_LOGGED_IN; 767 768 iscsi_set_connection_parameters(conn->conn_ops, conn->param_list); 769 iscsit_set_sync_and_steering_values(conn); 770 /* 771 * SCSI Initiator -> SCSI Target Port Mapping 772 */ 773 if (!zero_tsih) { 774 iscsi_set_session_parameters(sess->sess_ops, 775 conn->param_list, 0); 776 iscsi_release_param_list(conn->param_list); 777 conn->param_list = NULL; 778 779 spin_lock_bh(&sess->conn_lock); 780 atomic_set(&sess->session_continuation, 0); 781 if (sess->session_state == TARG_SESS_STATE_FAILED) { 782 pr_debug("Moving to" 783 " TARG_SESS_STATE_LOGGED_IN.\n"); 784 sess->session_state = TARG_SESS_STATE_LOGGED_IN; 785 stop_timer = 1; 786 } 787 788 pr_debug("iSCSI Login successful on CID: %hu from %s to" 789 " %s:%hu,%hu\n", conn->cid, conn->login_ip, 790 conn->local_ip, conn->local_port, tpg->tpgt); 791 792 list_add_tail(&conn->conn_list, &sess->sess_conn_list); 793 atomic_inc(&sess->nconn); 794 pr_debug("Incremented iSCSI Connection count to %hu" 795 " from node: %s\n", atomic_read(&sess->nconn), 796 sess->sess_ops->InitiatorName); 797 spin_unlock_bh(&sess->conn_lock); 798 799 iscsi_post_login_start_timers(conn); 800 /* 801 * Determine CPU mask to ensure connection's RX and TX kthreads 802 * are scheduled on the same CPU. 803 */ 804 iscsit_thread_get_cpumask(conn); 805 conn->conn_rx_reset_cpumask = 1; 806 conn->conn_tx_reset_cpumask = 1; 807 /* 808 * Wakeup the sleeping iscsi_target_rx_thread() now that 809 * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state. 810 */ 811 complete(&conn->rx_login_comp); 812 iscsit_dec_conn_usage_count(conn); 813 814 if (stop_timer) { 815 spin_lock_bh(&se_tpg->session_lock); 816 iscsit_stop_time2retain_timer(sess); 817 spin_unlock_bh(&se_tpg->session_lock); 818 } 819 iscsit_dec_session_usage_count(sess); 820 return; 821 } 822 823 iscsi_set_session_parameters(sess->sess_ops, conn->param_list, 1); 824 iscsi_release_param_list(conn->param_list); 825 conn->param_list = NULL; 826 827 iscsit_determine_maxcmdsn(sess); 828 829 spin_lock_bh(&se_tpg->session_lock); 830 __transport_register_session(&sess->tpg->tpg_se_tpg, 831 se_sess->se_node_acl, se_sess, sess); 832 pr_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n"); 833 sess->session_state = TARG_SESS_STATE_LOGGED_IN; 834 835 pr_debug("iSCSI Login successful on CID: %hu from %s to %s:%hu,%hu\n", 836 conn->cid, conn->login_ip, conn->local_ip, conn->local_port, 837 tpg->tpgt); 838 839 spin_lock_bh(&sess->conn_lock); 840 list_add_tail(&conn->conn_list, &sess->sess_conn_list); 841 atomic_inc(&sess->nconn); 842 pr_debug("Incremented iSCSI Connection count to %hu from node:" 843 " %s\n", atomic_read(&sess->nconn), 844 sess->sess_ops->InitiatorName); 845 spin_unlock_bh(&sess->conn_lock); 846 847 sess->sid = tpg->sid++; 848 if (!sess->sid) 849 sess->sid = tpg->sid++; 850 pr_debug("Established iSCSI session from node: %s\n", 851 sess->sess_ops->InitiatorName); 852 853 tpg->nsessions++; 854 if (tpg->tpg_tiqn) 855 tpg->tpg_tiqn->tiqn_nsessions++; 856 857 pr_debug("Incremented number of active iSCSI sessions to %u on" 858 " iSCSI Target Portal Group: %hu\n", tpg->nsessions, tpg->tpgt); 859 spin_unlock_bh(&se_tpg->session_lock); 860 861 iscsi_post_login_start_timers(conn); 862 /* 863 * Determine CPU mask to ensure connection's RX and TX kthreads 864 * are scheduled on the same CPU. 865 */ 866 iscsit_thread_get_cpumask(conn); 867 conn->conn_rx_reset_cpumask = 1; 868 conn->conn_tx_reset_cpumask = 1; 869 /* 870 * Wakeup the sleeping iscsi_target_rx_thread() now that 871 * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state. 872 */ 873 complete(&conn->rx_login_comp); 874 iscsit_dec_conn_usage_count(conn); 875} 876 877static void iscsi_handle_login_thread_timeout(unsigned long data) 878{ 879 struct iscsi_np *np = (struct iscsi_np *) data; 880 881 spin_lock_bh(&np->np_thread_lock); 882 pr_err("iSCSI Login timeout on Network Portal %pISc:%hu\n", 883 &np->np_sockaddr, np->np_port); 884 885 if (np->np_login_timer_flags & ISCSI_TF_STOP) { 886 spin_unlock_bh(&np->np_thread_lock); 887 return; 888 } 889 890 if (np->np_thread) 891 send_sig(SIGINT, np->np_thread, 1); 892 893 np->np_login_timer_flags &= ~ISCSI_TF_RUNNING; 894 spin_unlock_bh(&np->np_thread_lock); 895} 896 897static void iscsi_start_login_thread_timer(struct iscsi_np *np) 898{ 899 /* 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 902 */ 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); 911 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); 915} 916 917static void iscsi_stop_login_thread_timer(struct iscsi_np *np) 918{ 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); 922 return; 923 } 924 np->np_login_timer_flags |= ISCSI_TF_STOP; 925 spin_unlock_bh(&np->np_thread_lock); 926 927 del_timer_sync(&np->np_login_timer); 928 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); 932} 933 934int iscsit_setup_np( 935 struct iscsi_np *np, 936 struct __kernel_sockaddr_storage *sockaddr) 937{ 938 struct socket *sock = NULL; 939 int backlog = ISCSIT_TCP_BACKLOG, ret, opt = 0, len; 940 941 switch (np->np_network_transport) { 942 case ISCSI_TCP: 943 np->np_ip_proto = IPPROTO_TCP; 944 np->np_sock_type = SOCK_STREAM; 945 break; 946 case ISCSI_SCTP_TCP: 947 np->np_ip_proto = IPPROTO_SCTP; 948 np->np_sock_type = SOCK_STREAM; 949 break; 950 case ISCSI_SCTP_UDP: 951 np->np_ip_proto = IPPROTO_SCTP; 952 np->np_sock_type = SOCK_SEQPACKET; 953 break; 954 default: 955 pr_err("Unsupported network_transport: %d\n", 956 np->np_network_transport); 957 return -EINVAL; 958 } 959 960 np->np_ip_proto = IPPROTO_TCP; 961 np->np_sock_type = SOCK_STREAM; 962 963 ret = sock_create(sockaddr->ss_family, np->np_sock_type, 964 np->np_ip_proto, &sock); 965 if (ret < 0) { 966 pr_err("sock_create() failed.\n"); 967 return ret; 968 } 969 np->np_socket = sock; 970 /* 971 * Setup the np->np_sockaddr from the passed sockaddr setup 972 * in iscsi_target_configfs.c code.. 973 */ 974 memcpy(&np->np_sockaddr, sockaddr, 975 sizeof(struct __kernel_sockaddr_storage)); 976 977 if (sockaddr->ss_family == AF_INET6) 978 len = sizeof(struct sockaddr_in6); 979 else 980 len = sizeof(struct sockaddr_in); 981 /* 982 * Set SO_REUSEADDR, and disable Nagel Algorithm with TCP_NODELAY. 983 */ 984 /* FIXME: Someone please explain why this is endian-safe */ 985 opt = 1; 986 if (np->np_network_transport == ISCSI_TCP) { 987 ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, 988 (char *)&opt, sizeof(opt)); 989 if (ret < 0) { 990 pr_err("kernel_setsockopt() for TCP_NODELAY" 991 " failed: %d\n", ret); 992 goto fail; 993 } 994 } 995 996 /* FIXME: Someone please explain why this is endian-safe */ 997 ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 998 (char *)&opt, sizeof(opt)); 999 if (ret < 0) { 1000 pr_err("kernel_setsockopt() for SO_REUSEADDR" 1001 " failed\n"); 1002 goto fail; 1003 } 1004 1005 ret = kernel_setsockopt(sock, IPPROTO_IP, IP_FREEBIND, 1006 (char *)&opt, sizeof(opt)); 1007 if (ret < 0) { 1008 pr_err("kernel_setsockopt() for IP_FREEBIND" 1009 " failed\n"); 1010 goto fail; 1011 } 1012 1013 ret = kernel_bind(sock, (struct sockaddr *)&np->np_sockaddr, len); 1014 if (ret < 0) { 1015 pr_err("kernel_bind() failed: %d\n", ret); 1016 goto fail; 1017 } 1018 1019 ret = kernel_listen(sock, backlog); 1020 if (ret != 0) { 1021 pr_err("kernel_listen() failed: %d\n", ret); 1022 goto fail; 1023 } 1024 1025 return 0; 1026fail: 1027 np->np_socket = NULL; 1028 sock_release(sock); 1029 return ret; 1030} 1031 1032int iscsi_target_setup_login_socket( 1033 struct iscsi_np *np, 1034 struct __kernel_sockaddr_storage *sockaddr) 1035{ 1036 struct iscsit_transport *t; 1037 int rc; 1038 1039 t = iscsit_get_transport(np->np_network_transport); 1040 if (!t) 1041 return -EINVAL; 1042 1043 rc = t->iscsit_setup_np(np, sockaddr); 1044 if (rc < 0) { 1045 iscsit_put_transport(t); 1046 return rc; 1047 } 1048 1049 np->np_transport = t; 1050 np->enabled = true; 1051 return 0; 1052} 1053 1054int iscsit_accept_np(struct iscsi_np *np, struct iscsi_conn *conn) 1055{ 1056 struct socket *new_sock, *sock = np->np_socket; 1057 struct sockaddr_in sock_in; 1058 struct sockaddr_in6 sock_in6; 1059 int rc, err; 1060 1061 rc = kernel_accept(sock, &new_sock, 0); 1062 if (rc < 0) 1063 return rc; 1064 1065 conn->sock = new_sock; 1066 conn->login_family = np->np_sockaddr.ss_family; 1067 1068 if (np->np_sockaddr.ss_family == AF_INET6) { 1069 memset(&sock_in6, 0, sizeof(struct sockaddr_in6)); 1070 1071 rc = conn->sock->ops->getname(conn->sock, 1072 (struct sockaddr *)&sock_in6, &err, 1); 1073 if (!rc) { 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); 1077 else 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); 1081 } 1082 1083 rc = conn->sock->ops->getname(conn->sock, 1084 (struct sockaddr *)&sock_in6, &err, 0); 1085 if (!rc) { 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); 1089 else 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); 1093 } 1094 } else { 1095 memset(&sock_in, 0, sizeof(struct sockaddr_in)); 1096 1097 rc = conn->sock->ops->getname(conn->sock, 1098 (struct sockaddr *)&sock_in, &err, 1); 1099 if (!rc) { 1100 sprintf(conn->login_ip, "%pI4", 1101 &sock_in.sin_addr.s_addr); 1102 conn->login_port = ntohs(sock_in.sin_port); 1103 } 1104 1105 rc = conn->sock->ops->getname(conn->sock, 1106 (struct sockaddr *)&sock_in, &err, 0); 1107 if (!rc) { 1108 sprintf(conn->local_ip, "%pI4", 1109 &sock_in.sin_addr.s_addr); 1110 conn->local_port = ntohs(sock_in.sin_port); 1111 } 1112 } 1113 1114 return 0; 1115} 1116 1117int iscsit_get_login_rx(struct iscsi_conn *conn, struct iscsi_login *login) 1118{ 1119 struct iscsi_login_req *login_req; 1120 u32 padding = 0, payload_length; 1121 1122 if (iscsi_login_rx_data(conn, login->req, ISCSI_HDR_LEN) < 0) 1123 return -1; 1124 1125 login_req = (struct iscsi_login_req *)login->req; 1126 payload_length = ntoh24(login_req->dlength); 1127 padding = ((-payload_length) & 3); 1128 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); 1133 /* 1134 * Setup the initial iscsi_login values from the leading 1135 * login request PDU. 1136 */ 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); 1149 } 1150 1151 if (iscsi_target_check_login_request(conn, login) < 0) 1152 return -1; 1153 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) 1157 return -1; 1158 1159 return 0; 1160} 1161 1162int iscsit_put_login_tx(struct iscsi_conn *conn, struct iscsi_login *login, 1163 u32 length) 1164{ 1165 if (iscsi_login_tx_data(conn, login->rsp, login->rsp_buf, length) < 0) 1166 return -1; 1167 1168 return 0; 1169} 1170 1171static int 1172iscsit_conn_set_transport(struct iscsi_conn *conn, struct iscsit_transport *t) 1173{ 1174 int rc; 1175 1176 if (!t->owner) { 1177 conn->conn_transport = t; 1178 return 0; 1179 } 1180 1181 rc = try_module_get(t->owner); 1182 if (!rc) { 1183 pr_err("try_module_get() failed for %s\n", t->name); 1184 return -EINVAL; 1185 } 1186 1187 conn->conn_transport = t; 1188 return 0; 1189} 1190 1191void iscsi_target_login_sess_out(struct iscsi_conn *conn, 1192 struct iscsi_np *np, bool zero_tsih, bool new_sess) 1193{ 1194 if (!new_sess) 1195 goto old_sess_out; 1196 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) 1201 goto old_sess_out; 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); 1208 } 1209 kfree(conn->sess->sess_ops); 1210 kfree(conn->sess); 1211 conn->sess = NULL; 1212 1213old_sess_out: 1214 iscsi_stop_login_thread_timer(np); 1215 /* 1216 * If login negotiation fails check if the Time2Retain timer 1217 * needs to be restarted. 1218 */ 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; 1224 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); 1230 } else 1231 spin_unlock_bh(&conn->sess->conn_lock); 1232 iscsit_dec_session_usage_count(conn->sess); 1233 } 1234 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); 1239 1240 free_cpumask_var(conn->conn_cpumask); 1241 1242 kfree(conn->conn_ops); 1243 1244 if (conn->param_list) { 1245 iscsi_release_param_list(conn->param_list); 1246 conn->param_list = NULL; 1247 } 1248 iscsi_target_nego_release(conn); 1249 1250 if (conn->sock) { 1251 sock_release(conn->sock); 1252 conn->sock = NULL; 1253 } 1254 1255 if (conn->conn_transport->iscsit_wait_conn) 1256 conn->conn_transport->iscsit_wait_conn(conn); 1257 1258 if (conn->conn_transport->iscsit_free_conn) 1259 conn->conn_transport->iscsit_free_conn(conn); 1260 1261 iscsit_put_transport(conn->conn_transport); 1262 kfree(conn); 1263} 1264 1265static int __iscsi_target_login_thread(struct iscsi_np *np) 1266{ 1267 u8 *buffer, zero_tsih = 0; 1268 int ret = 0, rc; 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; 1275 1276 flush_signals(current); 1277 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); 1284 goto exit; 1285 } else { 1286 np->np_thread_state = ISCSI_NP_THREAD_ACTIVE; 1287 } 1288 spin_unlock_bh(&np->np_thread_lock); 1289 1290 conn = kzalloc(sizeof(struct iscsi_conn), GFP_KERNEL); 1291 if (!conn) { 1292 pr_err("Could not allocate memory for" 1293 " new connection\n"); 1294 /* Get another socket */ 1295 return 1; 1296 } 1297 pr_debug("Moving to TARG_CONN_STATE_FREE.\n"); 1298 conn->conn_state = TARG_CONN_STATE_FREE; 1299 1300 if (iscsit_conn_set_transport(conn, np->np_transport) < 0) { 1301 kfree(conn); 1302 return 1; 1303 } 1304 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); 1309 kfree(conn); 1310 conn = NULL; 1311 goto exit; 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); 1318 kfree(conn); 1319 conn = NULL; 1320 /* Get another socket */ 1321 return 1; 1322 } 1323 spin_unlock_bh(&np->np_thread_lock); 1324 iscsit_put_transport(conn->conn_transport); 1325 kfree(conn); 1326 conn = NULL; 1327 goto out; 1328 } 1329 /* 1330 * Perform the remaining iSCSI connection initialization items.. 1331 */ 1332 login = iscsi_login_init_conn(conn); 1333 if (!login) { 1334 goto new_sess_out; 1335 } 1336 1337 iscsi_start_login_thread_timer(np); 1338 1339 pr_debug("Moving to TARG_CONN_STATE_XPT_UP.\n"); 1340 conn->conn_state = TARG_CONN_STATE_XPT_UP; 1341 /* 1342 * This will process the first login request + payload.. 1343 */ 1344 rc = np->np_transport->iscsit_get_login_rx(conn, login); 1345 if (rc == 1) 1346 return 1; 1347 else if (rc < 0) 1348 goto new_sess_out; 1349 1350 buffer = &login->req[0]; 1351 pdu = (struct iscsi_login_req *)buffer; 1352 /* 1353 * Used by iscsit_tx_login_rsp() for Login Resonses PDUs 1354 * when Status-Class != 0. 1355 */ 1356 conn->login_itt = pdu->itt; 1357 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 %pISc:%hu currently not" 1362 " active.\n", &np->np_sockaddr, np->np_port); 1363 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 1364 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 1365 goto new_sess_out; 1366 } 1367 spin_unlock_bh(&np->np_thread_lock); 1368 1369 conn->network_transport = np->np_network_transport; 1370 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); 1374 1375 pr_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n"); 1376 conn->conn_state = TARG_CONN_STATE_IN_LOGIN; 1377 1378 if (iscsi_login_check_initiator_version(conn, pdu->max_version, 1379 pdu->min_version) < 0) 1380 goto new_sess_out; 1381 1382 zero_tsih = (pdu->tsih == 0x0000); 1383 if (zero_tsih) { 1384 /* 1385 * This is the leading connection of a new session. 1386 * We wait until after authentication to check for 1387 * session reinstatement. 1388 */ 1389 if (iscsi_login_zero_tsih_s1(conn, buffer) < 0) 1390 goto new_sess_out; 1391 } else { 1392 /* 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. 1398 */ 1399 if (iscsi_login_non_zero_tsih_s1(conn, buffer) < 0) 1400 goto new_sess_out; 1401 } 1402 /* 1403 * SessionType: Discovery 1404 * 1405 * Locates Default Portal 1406 * 1407 * SessionType: Normal 1408 * 1409 * Locates Target Portal from NP -> Target IQN 1410 */ 1411 rc = iscsi_target_locate_portal(np, conn, login); 1412 if (rc < 0) { 1413 tpg = conn->tpg; 1414 goto new_sess_out; 1415 } 1416 login->zero_tsih = zero_tsih; 1417 1418 conn->sess->se_sess->sup_prot_ops = 1419 conn->conn_transport->iscsit_get_sup_prot_ops(conn); 1420 1421 tpg = conn->tpg; 1422 if (!tpg) { 1423 pr_err("Unable to locate struct iscsi_conn->tpg\n"); 1424 goto new_sess_out; 1425 } 1426 1427 if (zero_tsih) { 1428 if (iscsi_login_zero_tsih_s2(conn) < 0) 1429 goto new_sess_out; 1430 } else { 1431 if (iscsi_login_non_zero_tsih_s2(conn, buffer) < 0) 1432 goto old_sess_out; 1433 } 1434 1435 ret = iscsi_target_start_negotiation(login, conn); 1436 if (ret < 0) 1437 goto new_sess_out; 1438 1439 iscsi_stop_login_thread_timer(np); 1440 1441 if (ret == 1) { 1442 tpg_np = conn->tpg_np; 1443 1444 iscsi_post_login_handler(np, conn, zero_tsih); 1445 iscsit_deaccess_np(np, tpg, tpg_np); 1446 } 1447 1448 tpg = NULL; 1449 tpg_np = NULL; 1450 /* Get another socket */ 1451 return 1; 1452 1453new_sess_out: 1454 new_sess = true; 1455old_sess_out: 1456 tpg_np = conn->tpg_np; 1457 iscsi_target_login_sess_out(conn, np, zero_tsih, new_sess); 1458 new_sess = false; 1459 1460 if (tpg) { 1461 iscsit_deaccess_np(np, tpg, tpg_np); 1462 tpg = NULL; 1463 tpg_np = NULL; 1464 } 1465 1466out: 1467 return 1; 1468 1469exit: 1470 iscsi_stop_login_thread_timer(np); 1471 spin_lock_bh(&np->np_thread_lock); 1472 np->np_thread_state = ISCSI_NP_THREAD_EXIT; 1473 spin_unlock_bh(&np->np_thread_lock); 1474 1475 return 0; 1476} 1477 1478int iscsi_target_login_thread(void *arg) 1479{ 1480 struct iscsi_np *np = arg; 1481 int ret; 1482 1483 allow_signal(SIGINT); 1484 1485 while (1) { 1486 ret = __iscsi_target_login_thread(np); 1487 /* 1488 * We break and exit here unless another sock_accept() call 1489 * is expected. 1490 */ 1491 if (ret != 1) 1492 break; 1493 } 1494 1495 return 0; 1496} 1497