1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <sys/cpuvar.h> 27 #include <sys/ddi.h> 28 #include <sys/sunddi.h> 29 #include <sys/modctl.h> 30 #include <sys/socket.h> 31 #include <sys/strsubr.h> 32 #include <sys/note.h> 33 #include <sys/sdt.h> 34 35 #define IDM_CONN_SM_STRINGS 36 #define IDM_CN_NOTIFY_STRINGS 37 #include <sys/idm/idm.h> 38 39 boolean_t idm_sm_logging = B_FALSE; 40 41 extern idm_global_t idm; /* Global state */ 42 43 static void 44 idm_conn_event_handler(void *event_ctx_opaque); 45 46 static void 47 idm_state_s1_free(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 48 49 static void 50 idm_state_s2_xpt_wait(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 51 52 static void 53 idm_state_s3_xpt_up(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 54 55 static void 56 idm_state_s4_in_login(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 57 58 static void 59 idm_state_s5_logged_in(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 60 61 static void 62 idm_state_s6_in_logout(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 63 64 static void 65 idm_logout_req_timeout(void *arg); 66 67 static void 68 idm_state_s7_logout_req(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 69 70 static void 71 idm_state_s8_cleanup(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 72 73 static void 74 idm_state_s9_init_error(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 75 76 static void 77 idm_state_s9a_rejected(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 78 79 static void 80 idm_state_s9b_wait_snd_done_cb(idm_pdu_t *pdu, 81 idm_status_t status); 82 83 static void 84 idm_state_s9b_wait_snd_done(idm_conn_t *ic, 85 idm_conn_event_ctx_t *event_ctx); 86 87 static void 88 idm_state_s10_in_cleanup(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 89 90 static void 91 idm_state_s11_complete(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 92 93 static void 94 idm_state_s12_enable_dm(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 95 96 static void 97 idm_update_state(idm_conn_t *ic, idm_conn_state_t new_state, 98 idm_conn_event_ctx_t *event_ctx); 99 100 static void 101 idm_conn_unref(void *ic_void); 102 103 static void 104 idm_conn_reject_unref(void *ic_void); 105 106 static idm_pdu_event_action_t 107 idm_conn_sm_validate_pdu(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx, 108 idm_pdu_t *pdu); 109 110 static idm_status_t 111 idm_ffp_enable(idm_conn_t *ic); 112 113 static void 114 idm_ffp_disable(idm_conn_t *ic, idm_ffp_disable_t disable_type); 115 116 static void 117 idm_initial_login_actions(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 118 119 static void 120 idm_login_success_actions(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx); 121 122 idm_status_t 123 idm_conn_sm_init(idm_conn_t *ic) 124 { 125 char taskq_name[32]; 126 127 /* 128 * Caller should have assigned a unique connection ID. Use this 129 * connection ID to create a unique connection name string 130 */ 131 ASSERT(ic->ic_internal_cid != 0); 132 (void) snprintf(taskq_name, sizeof (taskq_name) - 1, "conn_sm%08x", 133 ic->ic_internal_cid); 134 135 ic->ic_state_taskq = taskq_create(taskq_name, 1, minclsyspri, 4, 16384, 136 TASKQ_PREPOPULATE); 137 if (ic->ic_state_taskq == NULL) { 138 return (IDM_STATUS_FAIL); 139 } 140 141 idm_sm_audit_init(&ic->ic_state_audit); 142 mutex_init(&ic->ic_state_mutex, NULL, MUTEX_DEFAULT, NULL); 143 cv_init(&ic->ic_state_cv, NULL, CV_DEFAULT, NULL); 144 145 ic->ic_state = CS_S1_FREE; 146 ic->ic_last_state = CS_S1_FREE; 147 148 return (IDM_STATUS_SUCCESS); 149 } 150 151 void 152 idm_conn_sm_fini(idm_conn_t *ic) 153 { 154 155 /* 156 * The connection may only be partially created. If there 157 * is no taskq, then the connection SM was not initialized. 158 */ 159 if (ic->ic_state_taskq == NULL) { 160 return; 161 } 162 163 taskq_destroy(ic->ic_state_taskq); 164 165 cv_destroy(&ic->ic_state_cv); 166 /* 167 * The thread that generated the event that got us here may still 168 * hold the ic_state_mutex. Once it is released we can safely 169 * destroy it since there is no way to locate the object now. 170 */ 171 mutex_enter(&ic->ic_state_mutex); 172 mutex_destroy(&ic->ic_state_mutex); 173 } 174 175 void 176 idm_conn_event(idm_conn_t *ic, idm_conn_event_t event, uintptr_t event_info) 177 { 178 mutex_enter(&ic->ic_state_mutex); 179 idm_conn_event_locked(ic, event, event_info, CT_NONE); 180 mutex_exit(&ic->ic_state_mutex); 181 } 182 183 184 idm_status_t 185 idm_conn_reinstate_event(idm_conn_t *old_ic, idm_conn_t *new_ic) 186 { 187 int result; 188 189 mutex_enter(&old_ic->ic_state_mutex); 190 if (((old_ic->ic_conn_type == CONN_TYPE_INI) && 191 (old_ic->ic_state != CS_S8_CLEANUP)) || 192 ((old_ic->ic_conn_type == CONN_TYPE_TGT) && 193 (old_ic->ic_state < CS_S5_LOGGED_IN))) { 194 result = IDM_STATUS_FAIL; 195 } else { 196 result = IDM_STATUS_SUCCESS; 197 new_ic->ic_reinstate_conn = old_ic; 198 idm_conn_event_locked(new_ic->ic_reinstate_conn, 199 CE_CONN_REINSTATE, (uintptr_t)new_ic, CT_NONE); 200 } 201 mutex_exit(&old_ic->ic_state_mutex); 202 203 return (result); 204 } 205 206 void 207 idm_conn_tx_pdu_event(idm_conn_t *ic, idm_conn_event_t event, 208 uintptr_t event_info) 209 { 210 ASSERT(mutex_owned(&ic->ic_state_mutex)); 211 ic->ic_pdu_events++; 212 idm_conn_event_locked(ic, event, event_info, CT_TX_PDU); 213 } 214 215 void 216 idm_conn_rx_pdu_event(idm_conn_t *ic, idm_conn_event_t event, 217 uintptr_t event_info) 218 { 219 ASSERT(mutex_owned(&ic->ic_state_mutex)); 220 ic->ic_pdu_events++; 221 idm_conn_event_locked(ic, event, event_info, CT_RX_PDU); 222 } 223 224 void 225 idm_conn_event_locked(idm_conn_t *ic, idm_conn_event_t event, 226 uintptr_t event_info, idm_pdu_event_type_t pdu_event_type) 227 { 228 idm_conn_event_ctx_t *event_ctx; 229 230 ASSERT(mutex_owned(&ic->ic_state_mutex)); 231 232 idm_sm_audit_event(&ic->ic_state_audit, SAS_IDM_CONN, 233 (int)ic->ic_state, (int)event, event_info); 234 235 /* 236 * It's very difficult to prevent a few straggling events 237 * at the end. For example idm_sorx_thread will generate 238 * a CE_TRANSPORT_FAIL event when it exits. Rather than 239 * push complicated restrictions all over the code to 240 * prevent this we will simply drop the events (and in 241 * the case of PDU events release them appropriately) 242 * since they are irrelevant once we are in a terminal state. 243 * Of course those threads need to have appropriate holds on 244 * the connection otherwise it might disappear. 245 */ 246 if ((ic->ic_state == CS_S9_INIT_ERROR) || 247 (ic->ic_state == CS_S9A_REJECTED) || 248 (ic->ic_state == CS_S11_COMPLETE)) { 249 if ((pdu_event_type == CT_TX_PDU) || 250 (pdu_event_type == CT_RX_PDU)) { 251 ic->ic_pdu_events--; 252 idm_pdu_complete((idm_pdu_t *)event_info, 253 IDM_STATUS_SUCCESS); 254 } 255 IDM_SM_LOG(CE_NOTE, "*** Dropping event %s (%d) because of" 256 "state %s (%d)", 257 idm_ce_name[event], event, 258 idm_cs_name[ic->ic_state], ic->ic_state); 259 return; 260 } 261 262 /* 263 * Normal event handling 264 */ 265 idm_conn_hold(ic); 266 267 event_ctx = kmem_zalloc(sizeof (*event_ctx), KM_SLEEP); 268 event_ctx->iec_ic = ic; 269 event_ctx->iec_event = event; 270 event_ctx->iec_info = event_info; 271 event_ctx->iec_pdu_event_type = pdu_event_type; 272 273 (void) taskq_dispatch(ic->ic_state_taskq, &idm_conn_event_handler, 274 event_ctx, TQ_SLEEP); 275 } 276 277 static void 278 idm_conn_event_handler(void *event_ctx_opaque) 279 { 280 idm_conn_event_ctx_t *event_ctx = event_ctx_opaque; 281 idm_conn_t *ic = event_ctx->iec_ic; 282 idm_pdu_t *pdu = (idm_pdu_t *)event_ctx->iec_info; 283 idm_pdu_event_action_t action; 284 285 IDM_SM_LOG(CE_NOTE, "idm_conn_event_handler: conn %p event %s(%d)", 286 (void *)ic, idm_ce_name[event_ctx->iec_event], 287 event_ctx->iec_event); 288 DTRACE_PROBE2(conn__event, 289 idm_conn_t *, ic, idm_conn_event_ctx_t *, event_ctx); 290 291 /* 292 * Validate event 293 */ 294 ASSERT(event_ctx->iec_event != CE_UNDEFINED); 295 ASSERT3U(event_ctx->iec_event, <, CE_MAX_EVENT); 296 297 /* 298 * Validate current state 299 */ 300 ASSERT(ic->ic_state != CS_S0_UNDEFINED); 301 ASSERT3U(ic->ic_state, <, CS_MAX_STATE); 302 303 /* 304 * Validate PDU-related events against the current state. If a PDU 305 * is not allowed in the current state we change the event to a 306 * protocol error. This simplifies the state-specific event handlers. 307 * For example the CS_S2_XPT_WAIT state only needs to handle the 308 * CE_TX_PROTOCOL_ERROR and CE_RX_PROTOCOL_ERROR events since 309 * no PDU's can be transmitted or received in that state. 310 */ 311 event_ctx->iec_pdu_forwarded = B_FALSE; 312 if (event_ctx->iec_pdu_event_type != CT_NONE) { 313 ASSERT(pdu != NULL); 314 action = idm_conn_sm_validate_pdu(ic, event_ctx, pdu); 315 316 switch (action) { 317 case CA_TX_PROTOCOL_ERROR: 318 /* 319 * Change event and forward the PDU 320 */ 321 event_ctx->iec_event = CE_TX_PROTOCOL_ERROR; 322 break; 323 case CA_RX_PROTOCOL_ERROR: 324 /* 325 * Change event and forward the PDU. 326 */ 327 event_ctx->iec_event = CE_RX_PROTOCOL_ERROR; 328 break; 329 case CA_FORWARD: 330 /* 331 * Let the state-specific event handlers take 332 * care of it. 333 */ 334 break; 335 case CA_DROP: 336 /* 337 * It never even happened 338 */ 339 IDM_SM_LOG(CE_NOTE, "*** drop PDU %p", (void *) pdu); 340 idm_pdu_complete(pdu, IDM_STATUS_FAIL); 341 break; 342 default: 343 ASSERT(0); 344 break; 345 } 346 } 347 348 switch (ic->ic_state) { 349 case CS_S1_FREE: 350 idm_state_s1_free(ic, event_ctx); 351 break; 352 case CS_S2_XPT_WAIT: 353 idm_state_s2_xpt_wait(ic, event_ctx); 354 break; 355 case CS_S3_XPT_UP: 356 idm_state_s3_xpt_up(ic, event_ctx); 357 break; 358 case CS_S4_IN_LOGIN: 359 idm_state_s4_in_login(ic, event_ctx); 360 break; 361 case CS_S5_LOGGED_IN: 362 idm_state_s5_logged_in(ic, event_ctx); 363 break; 364 case CS_S6_IN_LOGOUT: 365 idm_state_s6_in_logout(ic, event_ctx); 366 break; 367 case CS_S7_LOGOUT_REQ: 368 idm_state_s7_logout_req(ic, event_ctx); 369 break; 370 case CS_S8_CLEANUP: 371 idm_state_s8_cleanup(ic, event_ctx); 372 break; 373 case CS_S9A_REJECTED: 374 idm_state_s9a_rejected(ic, event_ctx); 375 break; 376 case CS_S9B_WAIT_SND_DONE: 377 idm_state_s9b_wait_snd_done(ic, event_ctx); 378 break; 379 case CS_S9_INIT_ERROR: 380 idm_state_s9_init_error(ic, event_ctx); 381 break; 382 case CS_S10_IN_CLEANUP: 383 idm_state_s10_in_cleanup(ic, event_ctx); 384 break; 385 case CS_S11_COMPLETE: 386 idm_state_s11_complete(ic, event_ctx); 387 break; 388 case CS_S12_ENABLE_DM: 389 idm_state_s12_enable_dm(ic, event_ctx); 390 break; 391 default: 392 ASSERT(0); 393 break; 394 } 395 396 /* 397 * Now that we've updated the state machine, if this was 398 * a PDU-related event take the appropriate action on the PDU 399 * (transmit it, forward it to the clients RX callback, drop 400 * it, etc). 401 */ 402 if (event_ctx->iec_pdu_event_type != CT_NONE) { 403 switch (action) { 404 case CA_TX_PROTOCOL_ERROR: 405 idm_pdu_tx_protocol_error(ic, pdu); 406 break; 407 case CA_RX_PROTOCOL_ERROR: 408 idm_pdu_rx_protocol_error(ic, pdu); 409 break; 410 case CA_FORWARD: 411 if (!event_ctx->iec_pdu_forwarded) { 412 if (event_ctx->iec_pdu_event_type == 413 CT_RX_PDU) { 414 idm_pdu_rx_forward(ic, pdu); 415 } else { 416 idm_pdu_tx_forward(ic, pdu); 417 } 418 } 419 break; 420 default: 421 ASSERT(0); 422 break; 423 } 424 } 425 426 /* 427 * Update outstanding PDU event count (see idm_pdu_tx for 428 * how this is used) 429 */ 430 if ((event_ctx->iec_pdu_event_type == CT_TX_PDU) || 431 (event_ctx->iec_pdu_event_type == CT_RX_PDU)) { 432 mutex_enter(&ic->ic_state_mutex); 433 ic->ic_pdu_events--; 434 mutex_exit(&ic->ic_state_mutex); 435 } 436 437 idm_conn_rele(ic); 438 kmem_free(event_ctx, sizeof (*event_ctx)); 439 } 440 441 static void 442 idm_state_s1_free(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 443 { 444 switch (event_ctx->iec_event) { 445 case CE_CONNECT_REQ: 446 /* T1 */ 447 idm_update_state(ic, CS_S2_XPT_WAIT, event_ctx); 448 break; 449 case CE_CONNECT_ACCEPT: 450 /* T3 */ 451 idm_update_state(ic, CS_S3_XPT_UP, event_ctx); 452 break; 453 case CE_TX_PROTOCOL_ERROR: 454 case CE_RX_PROTOCOL_ERROR: 455 /* This should never happen */ 456 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 457 break; 458 default: 459 ASSERT(0); 460 /*NOTREACHED*/ 461 } 462 } 463 464 465 static void 466 idm_state_s2_xpt_wait(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 467 { 468 switch (event_ctx->iec_event) { 469 case CE_CONNECT_SUCCESS: 470 /* T4 */ 471 idm_update_state(ic, CS_S4_IN_LOGIN, event_ctx); 472 break; 473 case CE_TRANSPORT_FAIL: 474 case CE_CONNECT_FAIL: 475 case CE_LOGOUT_OTHER_CONN_RCV: 476 case CE_TX_PROTOCOL_ERROR: 477 case CE_RX_PROTOCOL_ERROR: 478 /* T2 */ 479 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 480 break; 481 default: 482 ASSERT(0); 483 /*NOTREACHED*/ 484 } 485 } 486 487 488 static void 489 idm_login_timeout(void *arg) 490 { 491 idm_conn_t *ic = arg; 492 493 idm_conn_event(ic, CE_LOGIN_TIMEOUT, NULL); 494 } 495 496 static void 497 idm_state_s3_xpt_up(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 498 { 499 switch (event_ctx->iec_event) { 500 case CE_LOGIN_RCV: 501 /* T4 */ 502 idm_initial_login_actions(ic, event_ctx); 503 idm_update_state(ic, CS_S4_IN_LOGIN, event_ctx); 504 break; 505 case CE_LOGIN_TIMEOUT: 506 /* 507 * Don't need to cancel login timer since the timer is 508 * presumed to be the source of this event. 509 */ 510 (void) idm_notify_client(ic, CN_LOGIN_FAIL, NULL); 511 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 512 break; 513 case CE_CONNECT_REJECT: 514 /* 515 * Iscsit doesn't want to hear from us again in this case. 516 * Since it rejected the connection it doesn't have a 517 * connection context to handle additional notifications. 518 * IDM needs to just clean things up on its own. 519 */ 520 (void) untimeout(ic->ic_state_timeout); 521 idm_update_state(ic, CS_S9A_REJECTED, event_ctx); 522 break; 523 case CE_CONNECT_FAIL: 524 case CE_TRANSPORT_FAIL: 525 case CE_LOGOUT_OTHER_CONN_SND: 526 /* T6 */ 527 (void) untimeout(ic->ic_state_timeout); 528 (void) idm_notify_client(ic, CN_LOGIN_FAIL, NULL); 529 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 530 break; 531 case CE_TX_PROTOCOL_ERROR: 532 case CE_RX_PROTOCOL_ERROR: 533 /* Don't care */ 534 break; 535 default: 536 ASSERT(0); 537 /*NOTREACHED*/ 538 } 539 } 540 541 static void 542 idm_state_s4_in_login(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 543 { 544 idm_pdu_t *pdu; 545 546 /* 547 * Login timer should no longer be active after leaving this 548 * state. 549 */ 550 switch (event_ctx->iec_event) { 551 case CE_LOGIN_SUCCESS_RCV: 552 case CE_LOGIN_SUCCESS_SND: 553 ASSERT(ic->ic_client_callback == NULL); 554 555 (void) untimeout(ic->ic_state_timeout); 556 idm_login_success_actions(ic, event_ctx); 557 if (ic->ic_rdma_extensions) { 558 /* T19 */ 559 idm_update_state(ic, CS_S12_ENABLE_DM, event_ctx); 560 } else { 561 /* T5 */ 562 idm_update_state(ic, CS_S5_LOGGED_IN, event_ctx); 563 } 564 break; 565 case CE_LOGIN_TIMEOUT: 566 /* T7 */ 567 (void) idm_notify_client(ic, CN_LOGIN_FAIL, NULL); 568 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 569 break; 570 case CE_LOGIN_FAIL_SND: 571 /* 572 * Allow the logout response pdu to be sent and defer 573 * the state machine cleanup until the completion callback. 574 * Only 1 level or callback interposition is allowed. 575 */ 576 (void) untimeout(ic->ic_state_timeout); 577 pdu = (idm_pdu_t *)event_ctx->iec_info; 578 ASSERT(ic->ic_client_callback == NULL); 579 ic->ic_client_callback = pdu->isp_callback; 580 pdu->isp_callback = 581 idm_state_s9b_wait_snd_done_cb; 582 idm_update_state(ic, CS_S9B_WAIT_SND_DONE, 583 event_ctx); 584 break; 585 case CE_LOGIN_FAIL_RCV: 586 ASSERT(ic->ic_client_callback == NULL); 587 /* 588 * Need to deliver this PDU to the initiator now because after 589 * we update the state to CS_S9_INIT_ERROR the initiator will 590 * no longer be in an appropriate state. 591 */ 592 event_ctx->iec_pdu_forwarded = B_TRUE; 593 pdu = (idm_pdu_t *)event_ctx->iec_info; 594 idm_pdu_rx_forward(ic, pdu); 595 /* FALLTHROUGH */ 596 case CE_TRANSPORT_FAIL: 597 case CE_LOGOUT_OTHER_CONN_SND: 598 case CE_LOGOUT_OTHER_CONN_RCV: 599 /* T7 */ 600 (void) untimeout(ic->ic_state_timeout); 601 (void) idm_notify_client(ic, CN_LOGIN_FAIL, NULL); 602 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 603 break; 604 case CE_LOGOUT_SESSION_SUCCESS: 605 /* 606 * T8 607 * A session reinstatement request can be received while a 608 * session is active and a login is in process. The iSCSI 609 * connections are shut down by a CE_LOGOUT_SESSION_SUCCESS 610 * event sent from the session to the IDM layer. 611 */ 612 if (IDM_CONN_ISTGT(ic)) { 613 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 614 } else { 615 ic->ic_transport_ops->it_ini_conn_disconnect(ic); 616 } 617 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 618 break; 619 620 case CE_LOGIN_SND: 621 ASSERT(ic->ic_client_callback == NULL); 622 /* 623 * Initiator connections will see initial login PDU 624 * in this state. Target connections see initial 625 * login PDU in "xpt up" state. 626 */ 627 mutex_enter(&ic->ic_state_mutex); 628 if (!(ic->ic_state_flags & CF_INITIAL_LOGIN)) { 629 idm_initial_login_actions(ic, event_ctx); 630 } 631 mutex_exit(&ic->ic_state_mutex); 632 break; 633 case CE_MISC_TX: 634 case CE_MISC_RX: 635 case CE_LOGIN_RCV: 636 case CE_TX_PROTOCOL_ERROR: 637 case CE_RX_PROTOCOL_ERROR: 638 /* Don't care */ 639 break; 640 default: 641 ASSERT(0); 642 /*NOTREACHED*/ 643 } 644 } 645 646 647 static void 648 idm_state_s5_logged_in(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 649 { 650 switch (event_ctx->iec_event) { 651 case CE_MISC_RX: 652 /* MC/S: when removing the non-leading connection */ 653 case CE_LOGOUT_THIS_CONN_RCV: 654 case CE_LOGOUT_THIS_CONN_SND: 655 case CE_LOGOUT_OTHER_CONN_RCV: 656 case CE_LOGOUT_OTHER_CONN_SND: 657 /* T9 */ 658 idm_ffp_disable(ic, FD_CONN_LOGOUT); /* Explicit logout */ 659 idm_update_state(ic, CS_S6_IN_LOGOUT, event_ctx); 660 break; 661 case CE_LOGOUT_SESSION_RCV: 662 case CE_LOGOUT_SESSION_SND: 663 /* T9 */ 664 idm_ffp_disable(ic, FD_SESS_LOGOUT); /* Explicit logout */ 665 idm_update_state(ic, CS_S6_IN_LOGOUT, event_ctx); 666 break; 667 case CE_LOGOUT_SESSION_SUCCESS: 668 /* T8 */ 669 idm_ffp_disable(ic, FD_SESS_LOGOUT); /* Explicit logout */ 670 671 /* Close connection */ 672 if (IDM_CONN_ISTGT(ic)) { 673 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 674 } else { 675 ic->ic_transport_ops->it_ini_conn_disconnect(ic); 676 } 677 678 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 679 break; 680 case CE_ASYNC_LOGOUT_RCV: 681 case CE_ASYNC_LOGOUT_SND: 682 /* T11 */ 683 idm_update_state(ic, CS_S7_LOGOUT_REQ, event_ctx); 684 break; 685 case CE_TRANSPORT_FAIL: 686 case CE_ASYNC_DROP_CONN_RCV: 687 case CE_ASYNC_DROP_CONN_SND: 688 case CE_ASYNC_DROP_ALL_CONN_RCV: 689 case CE_ASYNC_DROP_ALL_CONN_SND: 690 /* T15 */ 691 idm_ffp_disable(ic, FD_CONN_FAIL); /* Implicit logout */ 692 idm_update_state(ic, CS_S8_CLEANUP, event_ctx); 693 break; 694 case CE_MISC_TX: 695 case CE_TX_PROTOCOL_ERROR: 696 case CE_RX_PROTOCOL_ERROR: 697 case CE_LOGIN_TIMEOUT: 698 /* Don't care */ 699 break; 700 default: 701 ASSERT(0); 702 } 703 } 704 705 static void 706 idm_state_s6_in_logout_success_snd_done(idm_pdu_t *pdu, idm_status_t status) 707 { 708 idm_conn_t *ic = pdu->isp_ic; 709 710 /* 711 * This pdu callback can be invoked by the tx thread, 712 * so run the disconnect code from another thread. 713 */ 714 pdu->isp_status = status; 715 idm_conn_event(ic, CE_LOGOUT_SUCCESS_SND_DONE, (uintptr_t)pdu); 716 } 717 718 static void 719 idm_state_s6_in_logout_fail_snd_done(idm_pdu_t *pdu, idm_status_t status) 720 { 721 idm_conn_t *ic = pdu->isp_ic; 722 723 /* 724 * This pdu callback can be invoked by the tx thread, 725 * so run the disconnect code from another thread. 726 */ 727 pdu->isp_status = status; 728 idm_conn_event(ic, CE_LOGOUT_FAIL_SND_DONE, (uintptr_t)pdu); 729 } 730 731 static void 732 idm_state_s6_in_logout(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 733 { 734 idm_pdu_t *pdu; 735 736 switch (event_ctx->iec_event) { 737 case CE_LOGOUT_SUCCESS_SND_DONE: 738 pdu = (idm_pdu_t *)event_ctx->iec_info; 739 740 /* Close connection (if it's not already closed) */ 741 ASSERT(IDM_CONN_ISTGT(ic)); 742 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 743 744 /* restore client callback */ 745 pdu->isp_callback = ic->ic_client_callback; 746 ic->ic_client_callback = NULL; 747 idm_pdu_complete(pdu, pdu->isp_status); 748 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 749 break; 750 case CE_LOGOUT_FAIL_SND_DONE: 751 pdu = (idm_pdu_t *)event_ctx->iec_info; 752 /* restore client callback */ 753 pdu->isp_callback = ic->ic_client_callback; 754 ic->ic_client_callback = NULL; 755 idm_pdu_complete(pdu, pdu->isp_status); 756 idm_update_state(ic, CS_S8_CLEANUP, event_ctx); 757 break; 758 case CE_LOGOUT_SUCCESS_SND: 759 case CE_LOGOUT_FAIL_SND: 760 /* 761 * Allow the logout response pdu to be sent and defer 762 * the state machine update until the completion callback. 763 * Only 1 level or callback interposition is allowed. 764 */ 765 pdu = (idm_pdu_t *)event_ctx->iec_info; 766 ASSERT(ic->ic_client_callback == NULL); 767 ic->ic_client_callback = pdu->isp_callback; 768 if (event_ctx->iec_event == CE_LOGOUT_SUCCESS_SND) { 769 pdu->isp_callback = 770 idm_state_s6_in_logout_success_snd_done; 771 } else { 772 pdu->isp_callback = 773 idm_state_s6_in_logout_fail_snd_done; 774 } 775 break; 776 case CE_LOGOUT_SUCCESS_RCV: 777 /* 778 * Need to deliver this PDU to the initiator now because after 779 * we update the state to CS_S11_COMPLETE the initiator will 780 * no longer be in an appropriate state. 781 */ 782 event_ctx->iec_pdu_forwarded = B_TRUE; 783 pdu = (idm_pdu_t *)event_ctx->iec_info; 784 idm_pdu_rx_forward(ic, pdu); 785 /* FALLTHROUGH */ 786 case CE_LOGOUT_SESSION_SUCCESS: 787 /* T13 */ 788 789 /* Close connection (if it's not already closed) */ 790 if (IDM_CONN_ISTGT(ic)) { 791 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 792 } else { 793 ic->ic_transport_ops->it_ini_conn_disconnect(ic); 794 } 795 796 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 797 break; 798 case CE_ASYNC_LOGOUT_RCV: 799 /* T14 Do nothing */ 800 break; 801 case CE_TRANSPORT_FAIL: 802 case CE_ASYNC_DROP_CONN_RCV: 803 case CE_ASYNC_DROP_CONN_SND: 804 case CE_ASYNC_DROP_ALL_CONN_RCV: 805 case CE_ASYNC_DROP_ALL_CONN_SND: 806 case CE_LOGOUT_FAIL_RCV: 807 idm_update_state(ic, CS_S8_CLEANUP, event_ctx); 808 break; 809 case CE_TX_PROTOCOL_ERROR: 810 case CE_RX_PROTOCOL_ERROR: 811 case CE_MISC_TX: 812 case CE_MISC_RX: 813 case CE_LOGIN_TIMEOUT: 814 /* Don't care */ 815 break; 816 default: 817 ASSERT(0); 818 } 819 } 820 821 822 static void 823 idm_logout_req_timeout(void *arg) 824 { 825 idm_conn_t *ic = arg; 826 827 idm_conn_event(ic, CE_LOGOUT_TIMEOUT, NULL); 828 } 829 830 static void 831 idm_state_s7_logout_req(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 832 { 833 /* Must cancel logout timer before leaving this state */ 834 switch (event_ctx->iec_event) { 835 case CE_LOGOUT_THIS_CONN_RCV: 836 case CE_LOGOUT_THIS_CONN_SND: 837 case CE_LOGOUT_OTHER_CONN_RCV: 838 case CE_LOGOUT_OTHER_CONN_SND: 839 /* T10 */ 840 if (IDM_CONN_ISTGT(ic)) { 841 (void) untimeout(ic->ic_state_timeout); 842 } 843 idm_ffp_disable(ic, FD_CONN_LOGOUT); /* Explicit logout */ 844 idm_update_state(ic, CS_S6_IN_LOGOUT, event_ctx); 845 break; 846 case CE_LOGOUT_SESSION_RCV: 847 case CE_LOGOUT_SESSION_SND: 848 /* T10 */ 849 if (IDM_CONN_ISTGT(ic)) { 850 (void) untimeout(ic->ic_state_timeout); 851 } 852 idm_ffp_disable(ic, FD_SESS_LOGOUT); /* Explicit logout */ 853 idm_update_state(ic, CS_S6_IN_LOGOUT, event_ctx); 854 break; 855 case CE_ASYNC_LOGOUT_RCV: 856 case CE_ASYNC_LOGOUT_SND: 857 /* T12 Do nothing */ 858 break; 859 case CE_TRANSPORT_FAIL: 860 case CE_ASYNC_DROP_CONN_RCV: 861 case CE_ASYNC_DROP_CONN_SND: 862 case CE_ASYNC_DROP_ALL_CONN_RCV: 863 case CE_ASYNC_DROP_ALL_CONN_SND: 864 /* T16 */ 865 if (IDM_CONN_ISTGT(ic)) { 866 (void) untimeout(ic->ic_state_timeout); 867 } 868 /* FALLTHROUGH */ 869 case CE_LOGOUT_TIMEOUT: 870 idm_ffp_disable(ic, FD_CONN_FAIL); /* Implicit logout */ 871 idm_update_state(ic, CS_S8_CLEANUP, event_ctx); 872 break; 873 case CE_LOGOUT_SESSION_SUCCESS: 874 /* T18 */ 875 if (IDM_CONN_ISTGT(ic)) { 876 (void) untimeout(ic->ic_state_timeout); 877 } 878 idm_ffp_disable(ic, FD_SESS_LOGOUT); /* Explicit logout */ 879 880 /* Close connection (if it's not already closed) */ 881 if (IDM_CONN_ISTGT(ic)) { 882 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 883 } else { 884 ic->ic_transport_ops->it_ini_conn_disconnect(ic); 885 } 886 887 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 888 break; 889 case CE_TX_PROTOCOL_ERROR: 890 case CE_RX_PROTOCOL_ERROR: 891 case CE_MISC_TX: 892 case CE_MISC_RX: 893 case CE_LOGIN_TIMEOUT: 894 /* Don't care */ 895 break; 896 default: 897 ASSERT(0); 898 } 899 } 900 901 902 static void 903 idm_cleanup_timeout(void *arg) 904 { 905 idm_conn_t *ic = arg; 906 907 idm_conn_event(ic, CE_CLEANUP_TIMEOUT, NULL); 908 } 909 910 static void 911 idm_state_s8_cleanup(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 912 { 913 idm_pdu_t *pdu; 914 915 /* 916 * Need to cancel the cleanup timeout before leaving this state 917 * if it hasn't already fired. 918 */ 919 switch (event_ctx->iec_event) { 920 case CE_LOGOUT_SUCCESS_RCV: 921 case CE_LOGOUT_SUCCESS_SND: 922 case CE_LOGOUT_SESSION_SUCCESS: 923 (void) untimeout(ic->ic_state_timeout); 924 /*FALLTHROUGH*/ 925 case CE_CLEANUP_TIMEOUT: 926 /* M1 */ 927 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 928 break; 929 case CE_LOGOUT_OTHER_CONN_RCV: 930 case CE_LOGOUT_OTHER_CONN_SND: 931 /* M2 */ 932 idm_update_state(ic, CS_S10_IN_CLEANUP, event_ctx); 933 break; 934 case CE_LOGOUT_SUCCESS_SND_DONE: 935 case CE_LOGOUT_FAIL_SND_DONE: 936 pdu = (idm_pdu_t *)event_ctx->iec_info; 937 /* restore client callback */ 938 pdu->isp_callback = ic->ic_client_callback; 939 ic->ic_client_callback = NULL; 940 idm_pdu_complete(pdu, pdu->isp_status); 941 break; 942 case CE_LOGOUT_SESSION_RCV: 943 case CE_LOGOUT_SESSION_SND: 944 case CE_TX_PROTOCOL_ERROR: 945 case CE_RX_PROTOCOL_ERROR: 946 case CE_MISC_TX: 947 case CE_MISC_RX: 948 case CE_TRANSPORT_FAIL: 949 case CE_LOGIN_TIMEOUT: 950 case CE_LOGOUT_TIMEOUT: 951 /* Don't care */ 952 break; 953 default: 954 ASSERT(0); 955 } 956 } 957 958 /* ARGSUSED */ 959 static void 960 idm_state_s9_init_error(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 961 { 962 /* All events ignored in this state */ 963 } 964 965 /* ARGSUSED */ 966 static void 967 idm_state_s9a_rejected(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 968 { 969 /* All events ignored in this state */ 970 } 971 972 973 static void 974 idm_state_s9b_wait_snd_done_cb(idm_pdu_t *pdu, idm_status_t status) 975 { 976 idm_conn_t *ic = pdu->isp_ic; 977 978 /* 979 * This pdu callback can be invoked by the tx thread, 980 * so run the disconnect code from another thread. 981 */ 982 pdu->isp_status = status; 983 idm_conn_event(ic, CE_LOGIN_FAIL_SND_DONE, (uintptr_t)pdu); 984 } 985 986 /* 987 * CS_S9B_WAIT_SND_DONE -- wait for callback completion. 988 */ 989 /* ARGSUSED */ 990 static void 991 idm_state_s9b_wait_snd_done(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 992 { 993 idm_pdu_t *pdu; 994 /* 995 * Wait for completion of the login fail sequence and then 996 * go to state S9_INIT_ERROR to clean up the connection. 997 */ 998 switch (event_ctx->iec_event) { 999 case CE_LOGIN_FAIL_SND_DONE: 1000 pdu = (idm_pdu_t *)event_ctx->iec_info; 1001 /* restore client callback */ 1002 pdu->isp_callback = ic->ic_client_callback; 1003 ic->ic_client_callback = NULL; 1004 idm_pdu_complete(pdu, pdu->isp_status); 1005 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 1006 break; 1007 1008 /* All other events ignored */ 1009 } 1010 } 1011 1012 1013 1014 1015 static void 1016 idm_state_s10_in_cleanup(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 1017 { 1018 idm_pdu_t *pdu; 1019 1020 /* 1021 * Need to cancel the cleanup timeout before leaving this state 1022 * if it hasn't already fired. 1023 */ 1024 switch (event_ctx->iec_event) { 1025 case CE_LOGOUT_FAIL_RCV: 1026 case CE_LOGOUT_FAIL_SND: 1027 idm_update_state(ic, CS_S8_CLEANUP, event_ctx); 1028 break; 1029 case CE_LOGOUT_SUCCESS_SND: 1030 case CE_LOGOUT_SUCCESS_RCV: 1031 case CE_LOGOUT_SESSION_SUCCESS: 1032 (void) untimeout(ic->ic_state_timeout); 1033 /*FALLTHROUGH*/ 1034 case CE_CLEANUP_TIMEOUT: 1035 idm_update_state(ic, CS_S11_COMPLETE, event_ctx); 1036 break; 1037 case CE_LOGOUT_SUCCESS_SND_DONE: 1038 case CE_LOGOUT_FAIL_SND_DONE: 1039 pdu = (idm_pdu_t *)event_ctx->iec_info; 1040 /* restore client callback */ 1041 pdu->isp_callback = ic->ic_client_callback; 1042 ic->ic_client_callback = NULL; 1043 idm_pdu_complete(pdu, pdu->isp_status); 1044 break; 1045 case CE_TX_PROTOCOL_ERROR: 1046 case CE_RX_PROTOCOL_ERROR: 1047 case CE_MISC_TX: 1048 case CE_MISC_RX: 1049 case CE_LOGIN_TIMEOUT: 1050 case CE_LOGOUT_TIMEOUT: 1051 /* Don't care */ 1052 break; 1053 default: 1054 ASSERT(0); 1055 } 1056 } 1057 1058 /* ARGSUSED */ 1059 static void 1060 idm_state_s11_complete(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 1061 { 1062 idm_pdu_t *pdu; 1063 1064 /* 1065 * Cleanup logout success/fail completion if it's been delayed 1066 * until now. 1067 * 1068 * All new events are filtered out before reaching this state, but 1069 * there might already be events in the event queue, so handle the 1070 * SND_DONE events here. Note that if either of the following 1071 * SND_DONE events happens AFTER the change to state S11, then the 1072 * event filter inside dm_conn_event_locked does enough cleanup. 1073 */ 1074 switch (event_ctx->iec_event) { 1075 case CE_LOGOUT_SUCCESS_SND_DONE: 1076 case CE_LOGOUT_FAIL_SND_DONE: 1077 pdu = (idm_pdu_t *)event_ctx->iec_info; 1078 /* restore client callback */ 1079 pdu->isp_callback = ic->ic_client_callback; 1080 ic->ic_client_callback = NULL; 1081 idm_pdu_complete(pdu, pdu->isp_status); 1082 break; 1083 } 1084 1085 } 1086 1087 static void 1088 idm_state_s12_enable_dm(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 1089 { 1090 switch (event_ctx->iec_event) { 1091 case CE_ENABLE_DM_SUCCESS: 1092 /* T20 */ 1093 idm_update_state(ic, CS_S5_LOGGED_IN, event_ctx); 1094 break; 1095 case CE_ENABLE_DM_FAIL: 1096 /* T21 */ 1097 idm_update_state(ic, CS_S9_INIT_ERROR, event_ctx); 1098 break; 1099 case CE_TRANSPORT_FAIL: 1100 /* 1101 * We expect to always hear back from the transport layer 1102 * once we have an "enable data-mover" request outstanding. 1103 * Therefore we'll ignore other events that may occur even 1104 * when they clearly indicate a problem and wait for 1105 * CE_ENABLE_DM_FAIL. On a related note this means the 1106 * transport must ensure that it eventually completes the 1107 * "enable data-mover" operation with either success or 1108 * failure -- otherwise we'll be stuck here. 1109 */ 1110 break; 1111 default: 1112 ASSERT(0); 1113 break; 1114 } 1115 } 1116 1117 static void 1118 idm_update_state(idm_conn_t *ic, idm_conn_state_t new_state, 1119 idm_conn_event_ctx_t *event_ctx) 1120 { 1121 int rc; 1122 idm_status_t idm_status; 1123 1124 /* 1125 * Validate new state 1126 */ 1127 ASSERT(new_state != CS_S0_UNDEFINED); 1128 ASSERT3U(new_state, <, CS_MAX_STATE); 1129 1130 /* 1131 * Update state in context. We protect this with a mutex 1132 * even though the state machine code is single threaded so that 1133 * other threads can check the state value atomically. 1134 */ 1135 new_state = (new_state < CS_MAX_STATE) ? 1136 new_state : CS_S0_UNDEFINED; 1137 1138 IDM_SM_LOG(CE_NOTE, "idm_update_state: conn %p, evt %s(%d), " 1139 "%s(%d) --> %s(%d)", (void *)ic, 1140 idm_ce_name[event_ctx->iec_event], event_ctx->iec_event, 1141 idm_cs_name[ic->ic_state], ic->ic_state, 1142 idm_cs_name[new_state], new_state); 1143 1144 DTRACE_PROBE2(conn__state__change, 1145 idm_conn_t *, ic, idm_conn_state_t, new_state); 1146 1147 mutex_enter(&ic->ic_state_mutex); 1148 idm_sm_audit_state_change(&ic->ic_state_audit, SAS_IDM_CONN, 1149 (int)ic->ic_state, (int)new_state); 1150 ic->ic_last_state = ic->ic_state; 1151 ic->ic_state = new_state; 1152 cv_signal(&ic->ic_state_cv); 1153 mutex_exit(&ic->ic_state_mutex); 1154 1155 switch (ic->ic_state) { 1156 case CS_S1_FREE: 1157 ASSERT(0); /* Initial state, can't return */ 1158 break; 1159 case CS_S2_XPT_WAIT: 1160 if ((rc = idm_ini_conn_finish(ic)) != 0) { 1161 idm_conn_event(ic, CE_CONNECT_FAIL, NULL); 1162 } else { 1163 idm_conn_event(ic, CE_CONNECT_SUCCESS, NULL); 1164 } 1165 break; 1166 case CS_S3_XPT_UP: 1167 /* 1168 * Finish any connection related setup including 1169 * waking up the idm_tgt_conn_accept thread. 1170 * and starting the login timer. If the function 1171 * fails then we return to "free" state. 1172 */ 1173 if ((rc = idm_tgt_conn_finish(ic)) != IDM_STATUS_SUCCESS) { 1174 switch (rc) { 1175 case IDM_STATUS_REJECT: 1176 idm_conn_event(ic, CE_CONNECT_REJECT, NULL); 1177 break; 1178 default: 1179 idm_conn_event(ic, CE_CONNECT_FAIL, NULL); 1180 break; 1181 } 1182 } 1183 1184 /* 1185 * First login received will cause a transition to 1186 * CS_S4_IN_LOGIN. Start login timer. 1187 */ 1188 ic->ic_state_timeout = timeout(idm_login_timeout, ic, 1189 drv_usectohz(IDM_LOGIN_SECONDS*1000000)); 1190 break; 1191 case CS_S4_IN_LOGIN: 1192 if (ic->ic_conn_type == CONN_TYPE_INI) { 1193 (void) idm_notify_client(ic, CN_READY_FOR_LOGIN, NULL); 1194 mutex_enter(&ic->ic_state_mutex); 1195 ic->ic_state_flags |= CF_LOGIN_READY; 1196 cv_signal(&ic->ic_state_cv); 1197 mutex_exit(&ic->ic_state_mutex); 1198 } 1199 break; 1200 case CS_S5_LOGGED_IN: 1201 ASSERT(!ic->ic_ffp); 1202 /* 1203 * IDM can go to FFP before the initiator but it 1204 * needs to go to FFP after the target (IDM target should 1205 * go to FFP after notify_ack). 1206 */ 1207 idm_status = idm_ffp_enable(ic); 1208 if (idm_status != IDM_STATUS_SUCCESS) { 1209 idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL); 1210 } 1211 1212 if (ic->ic_reinstate_conn) { 1213 /* Connection reinstatement is complete */ 1214 idm_conn_event(ic->ic_reinstate_conn, 1215 CE_CONN_REINSTATE_SUCCESS, NULL); 1216 } 1217 break; 1218 case CS_S6_IN_LOGOUT: 1219 break; 1220 case CS_S7_LOGOUT_REQ: 1221 /* Start logout timer for target connections */ 1222 if (IDM_CONN_ISTGT(ic)) { 1223 ic->ic_state_timeout = timeout(idm_logout_req_timeout, 1224 ic, drv_usectohz(IDM_LOGOUT_SECONDS*1000000)); 1225 } 1226 break; 1227 case CS_S8_CLEANUP: 1228 /* Close connection (if it's not already closed) */ 1229 if (IDM_CONN_ISTGT(ic)) { 1230 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 1231 } else { 1232 ic->ic_transport_ops->it_ini_conn_disconnect(ic); 1233 } 1234 1235 /* Stop executing active tasks */ 1236 idm_task_abort(ic, NULL, AT_INTERNAL_SUSPEND); 1237 1238 /* Start logout timer */ 1239 ic->ic_state_timeout = timeout(idm_cleanup_timeout, ic, 1240 drv_usectohz(IDM_CLEANUP_SECONDS*1000000)); 1241 break; 1242 case CS_S10_IN_CLEANUP: 1243 break; 1244 case CS_S9A_REJECTED: 1245 /* 1246 * We never finished establishing the connection so no 1247 * disconnect. No client notifications because the client 1248 * rejected the connection. 1249 */ 1250 idm_refcnt_async_wait_ref(&ic->ic_refcnt, 1251 &idm_conn_reject_unref); 1252 break; 1253 case CS_S9B_WAIT_SND_DONE: 1254 break; 1255 case CS_S9_INIT_ERROR: 1256 if (IDM_CONN_ISTGT(ic)) { 1257 ic->ic_transport_ops->it_tgt_conn_disconnect(ic); 1258 } else { 1259 mutex_enter(&ic->ic_state_mutex); 1260 ic->ic_state_flags |= CF_ERROR; 1261 ic->ic_conn_sm_status = IDM_STATUS_FAIL; 1262 cv_signal(&ic->ic_state_cv); 1263 mutex_exit(&ic->ic_state_mutex); 1264 if (ic->ic_last_state != CS_S1_FREE && 1265 ic->ic_last_state != CS_S2_XPT_WAIT) { 1266 ic->ic_transport_ops->it_ini_conn_disconnect( 1267 ic); 1268 } else { 1269 (void) idm_notify_client(ic, CN_CONNECT_FAIL, 1270 NULL); 1271 } 1272 } 1273 /*FALLTHROUGH*/ 1274 case CS_S11_COMPLETE: 1275 /* 1276 * No more traffic on this connection. If this is an 1277 * initiator connection and we weren't connected yet 1278 * then don't send the "connect lost" event. 1279 * It's useful to the initiator to know whether we were 1280 * logging in at the time so send that information in the 1281 * data field. 1282 */ 1283 if (IDM_CONN_ISTGT(ic) || 1284 ((ic->ic_last_state != CS_S1_FREE) && 1285 (ic->ic_last_state != CS_S2_XPT_WAIT))) { 1286 (void) idm_notify_client(ic, CN_CONNECT_LOST, 1287 (uintptr_t)(ic->ic_last_state == CS_S4_IN_LOGIN)); 1288 } 1289 1290 /* Abort all tasks */ 1291 idm_task_abort(ic, NULL, AT_INTERNAL_ABORT); 1292 1293 /* 1294 * Handle terminal state actions on the global taskq so 1295 * we can clean up all the connection resources from 1296 * a separate thread context. 1297 */ 1298 idm_refcnt_async_wait_ref(&ic->ic_refcnt, &idm_conn_unref); 1299 break; 1300 case CS_S12_ENABLE_DM: 1301 1302 /* 1303 * The Enable DM state indicates the initiator to initiate 1304 * the hello sequence and the target to get ready to accept 1305 * the iSER Hello Message. 1306 */ 1307 idm_status = (IDM_CONN_ISINI(ic)) ? 1308 ic->ic_transport_ops->it_ini_enable_datamover(ic) : 1309 ic->ic_transport_ops->it_tgt_enable_datamover(ic); 1310 1311 if (idm_status == IDM_STATUS_SUCCESS) { 1312 idm_conn_event(ic, CE_ENABLE_DM_SUCCESS, NULL); 1313 } else { 1314 idm_conn_event(ic, CE_ENABLE_DM_FAIL, NULL); 1315 } 1316 1317 break; 1318 1319 default: 1320 ASSERT(0); 1321 break; 1322 1323 } 1324 } 1325 1326 1327 static void 1328 idm_conn_unref(void *ic_void) 1329 { 1330 idm_conn_t *ic = ic_void; 1331 1332 /* 1333 * Client should not be notified that the connection is destroyed 1334 * until all references on the idm connection have been removed. 1335 * Otherwise references on the associated client context would need 1336 * to be tracked separately which seems like a waste (at least when 1337 * there is a one for one correspondence with references on the 1338 * IDM connection). 1339 */ 1340 if (IDM_CONN_ISTGT(ic)) { 1341 (void) idm_notify_client(ic, CN_CONNECT_DESTROY, NULL); 1342 idm_svc_conn_destroy(ic); 1343 } else { 1344 /* Initiator may destroy connection during this call */ 1345 (void) idm_notify_client(ic, CN_CONNECT_DESTROY, NULL); 1346 } 1347 } 1348 1349 static void 1350 idm_conn_reject_unref(void *ic_void) 1351 { 1352 idm_conn_t *ic = ic_void; 1353 1354 ASSERT(IDM_CONN_ISTGT(ic)); 1355 1356 /* Don't notify the client since it rejected the connection */ 1357 idm_svc_conn_destroy(ic); 1358 } 1359 1360 1361 1362 static idm_pdu_event_action_t 1363 idm_conn_sm_validate_pdu(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx, 1364 idm_pdu_t *pdu) 1365 { 1366 char *reason_string; 1367 idm_pdu_event_action_t action; 1368 1369 ASSERT((event_ctx->iec_pdu_event_type == CT_RX_PDU) || 1370 (event_ctx->iec_pdu_event_type == CT_TX_PDU)); 1371 1372 /* 1373 * Let's check the simple stuff first. Make sure if this is a 1374 * target connection that the PDU is appropriate for a target 1375 * and if this is an initiator connection that the PDU is 1376 * appropriate for an initiator. This code is not in the data 1377 * path so organization is more important than performance. 1378 */ 1379 switch (IDM_PDU_OPCODE(pdu)) { 1380 case ISCSI_OP_NOOP_OUT: 1381 case ISCSI_OP_SCSI_CMD: 1382 case ISCSI_OP_SCSI_TASK_MGT_MSG: 1383 case ISCSI_OP_LOGIN_CMD: 1384 case ISCSI_OP_TEXT_CMD: 1385 case ISCSI_OP_SCSI_DATA: 1386 case ISCSI_OP_LOGOUT_CMD: 1387 case ISCSI_OP_SNACK_CMD: 1388 /* 1389 * Only the initiator should send these PDU's and 1390 * only the target should receive them. 1391 */ 1392 if (IDM_CONN_ISINI(ic) && 1393 (event_ctx->iec_pdu_event_type == CT_RX_PDU)) { 1394 reason_string = "Invalid RX PDU for initiator"; 1395 action = CA_RX_PROTOCOL_ERROR; 1396 goto validate_pdu_done; 1397 } 1398 1399 if (IDM_CONN_ISTGT(ic) && 1400 (event_ctx->iec_pdu_event_type == CT_TX_PDU)) { 1401 reason_string = "Invalid TX PDU for target"; 1402 action = CA_TX_PROTOCOL_ERROR; 1403 goto validate_pdu_done; 1404 } 1405 break; 1406 case ISCSI_OP_NOOP_IN: 1407 case ISCSI_OP_SCSI_RSP: 1408 case ISCSI_OP_SCSI_TASK_MGT_RSP: 1409 case ISCSI_OP_LOGIN_RSP: 1410 case ISCSI_OP_TEXT_RSP: 1411 case ISCSI_OP_SCSI_DATA_RSP: 1412 case ISCSI_OP_LOGOUT_RSP: 1413 case ISCSI_OP_RTT_RSP: 1414 case ISCSI_OP_ASYNC_EVENT: 1415 case ISCSI_OP_REJECT_MSG: 1416 /* 1417 * Only the target should send these PDU's and 1418 * only the initiator should receive them. 1419 */ 1420 if (IDM_CONN_ISTGT(ic) && 1421 (event_ctx->iec_pdu_event_type == CT_RX_PDU)) { 1422 reason_string = "Invalid RX PDU for target"; 1423 action = CA_RX_PROTOCOL_ERROR; 1424 goto validate_pdu_done; 1425 } 1426 1427 if (IDM_CONN_ISINI(ic) && 1428 (event_ctx->iec_pdu_event_type == CT_TX_PDU)) { 1429 reason_string = "Invalid TX PDU for initiator"; 1430 action = CA_TX_PROTOCOL_ERROR; 1431 goto validate_pdu_done; 1432 } 1433 break; 1434 default: 1435 reason_string = "Unknown PDU Type"; 1436 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1437 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1438 goto validate_pdu_done; 1439 } 1440 1441 /* 1442 * Now validate the opcodes against the current state. 1443 */ 1444 reason_string = "PDU not allowed in current state"; 1445 switch (IDM_PDU_OPCODE(pdu)) { 1446 case ISCSI_OP_NOOP_OUT: 1447 case ISCSI_OP_NOOP_IN: 1448 /* 1449 * Obviously S1-S3 are not allowed since login hasn't started. 1450 * S8 is probably out as well since the connection has been 1451 * dropped. 1452 */ 1453 switch (ic->ic_state) { 1454 case CS_S4_IN_LOGIN: 1455 case CS_S5_LOGGED_IN: 1456 case CS_S6_IN_LOGOUT: 1457 case CS_S7_LOGOUT_REQ: 1458 action = CA_FORWARD; 1459 goto validate_pdu_done; 1460 case CS_S8_CLEANUP: 1461 case CS_S10_IN_CLEANUP: 1462 action = CA_DROP; 1463 break; 1464 default: 1465 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1466 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1467 goto validate_pdu_done; 1468 } 1469 /*NOTREACHED*/ 1470 case ISCSI_OP_SCSI_CMD: 1471 case ISCSI_OP_SCSI_RSP: 1472 case ISCSI_OP_SCSI_TASK_MGT_MSG: 1473 case ISCSI_OP_SCSI_TASK_MGT_RSP: 1474 case ISCSI_OP_SCSI_DATA: 1475 case ISCSI_OP_SCSI_DATA_RSP: 1476 case ISCSI_OP_RTT_RSP: 1477 case ISCSI_OP_SNACK_CMD: 1478 case ISCSI_OP_TEXT_CMD: 1479 case ISCSI_OP_TEXT_RSP: 1480 switch (ic->ic_state) { 1481 case CS_S5_LOGGED_IN: 1482 case CS_S6_IN_LOGOUT: 1483 case CS_S7_LOGOUT_REQ: 1484 action = CA_FORWARD; 1485 goto validate_pdu_done; 1486 case CS_S8_CLEANUP: 1487 case CS_S10_IN_CLEANUP: 1488 action = CA_DROP; 1489 break; 1490 default: 1491 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1492 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1493 goto validate_pdu_done; 1494 } 1495 /*NOTREACHED*/ 1496 case ISCSI_OP_LOGOUT_CMD: 1497 case ISCSI_OP_LOGOUT_RSP: 1498 case ISCSI_OP_REJECT_MSG: 1499 case ISCSI_OP_ASYNC_EVENT: 1500 switch (ic->ic_state) { 1501 case CS_S5_LOGGED_IN: 1502 case CS_S6_IN_LOGOUT: 1503 case CS_S7_LOGOUT_REQ: 1504 action = CA_FORWARD; 1505 goto validate_pdu_done; 1506 case CS_S8_CLEANUP: 1507 case CS_S10_IN_CLEANUP: 1508 action = CA_DROP; 1509 break; 1510 default: 1511 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1512 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1513 goto validate_pdu_done; 1514 } 1515 /*NOTREACHED*/ 1516 case ISCSI_OP_LOGIN_CMD: 1517 case ISCSI_OP_LOGIN_RSP: 1518 switch (ic->ic_state) { 1519 case CS_S3_XPT_UP: 1520 case CS_S4_IN_LOGIN: 1521 action = CA_FORWARD; 1522 goto validate_pdu_done; 1523 default: 1524 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1525 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1526 goto validate_pdu_done; 1527 } 1528 /*NOTREACHED*/ 1529 default: 1530 /* This should never happen -- we already checked above */ 1531 ASSERT(0); 1532 /*NOTREACHED*/ 1533 } 1534 1535 action = ((event_ctx->iec_pdu_event_type == CT_TX_PDU) ? 1536 CA_TX_PROTOCOL_ERROR : CA_RX_PROTOCOL_ERROR); 1537 1538 validate_pdu_done: 1539 if (action != CA_FORWARD) { 1540 DTRACE_PROBE2(idm__int__protocol__error, 1541 idm_conn_event_ctx_t *, event_ctx, 1542 char *, reason_string); 1543 } 1544 1545 return (action); 1546 } 1547 1548 /* ARGSUSED */ 1549 void 1550 idm_pdu_tx_protocol_error(idm_conn_t *ic, idm_pdu_t *pdu) 1551 { 1552 /* 1553 * Return the PDU to the caller indicating it was a protocol error. 1554 * Caller can take appropriate action. 1555 */ 1556 idm_pdu_complete(pdu, IDM_STATUS_PROTOCOL_ERROR); 1557 } 1558 1559 void 1560 idm_pdu_rx_protocol_error(idm_conn_t *ic, idm_pdu_t *pdu) 1561 { 1562 /* 1563 * Forward PDU to caller indicating it is a protocol error. 1564 * Caller should take appropriate action. 1565 */ 1566 (*ic->ic_conn_ops.icb_rx_error)(ic, pdu, IDM_STATUS_PROTOCOL_ERROR); 1567 } 1568 1569 idm_status_t 1570 idm_notify_client(idm_conn_t *ic, idm_client_notify_t cn, uintptr_t data) 1571 { 1572 /* 1573 * We may want to make this more complicated at some point but 1574 * for now lets just call the client's notify function and return 1575 * the status. 1576 */ 1577 ASSERT(!mutex_owned(&ic->ic_state_mutex)); 1578 cn = (cn > CN_MAX) ? CN_MAX : cn; 1579 IDM_SM_LOG(CE_NOTE, "idm_notify_client: ic=%p %s(%d)\n", 1580 (void *)ic, idm_cn_strings[cn], cn); 1581 return ((*ic->ic_conn_ops.icb_client_notify)(ic, cn, data)); 1582 } 1583 1584 static idm_status_t 1585 idm_ffp_enable(idm_conn_t *ic) 1586 { 1587 idm_status_t rc; 1588 1589 /* 1590 * On the initiator side the client will see this notification 1591 * before the actual login succes PDU. This shouldn't be a big 1592 * deal since the initiator drives the connection. It can simply 1593 * wait for the login response then start sending SCSI commands. 1594 * Kind ugly though compared with the way things work on target 1595 * connections. 1596 */ 1597 mutex_enter(&ic->ic_state_mutex); 1598 ic->ic_ffp = B_TRUE; 1599 mutex_exit(&ic->ic_state_mutex); 1600 1601 rc = idm_notify_client(ic, CN_FFP_ENABLED, NULL); 1602 if (rc != IDM_STATUS_SUCCESS) { 1603 mutex_enter(&ic->ic_state_mutex); 1604 ic->ic_ffp = B_FALSE; 1605 mutex_exit(&ic->ic_state_mutex); 1606 } 1607 return (rc); 1608 } 1609 1610 static void 1611 idm_ffp_disable(idm_conn_t *ic, idm_ffp_disable_t disable_type) 1612 { 1613 mutex_enter(&ic->ic_state_mutex); 1614 ic->ic_ffp = B_FALSE; 1615 mutex_exit(&ic->ic_state_mutex); 1616 1617 /* Client can't "fail" CN_FFP_DISABLED */ 1618 (void) idm_notify_client(ic, CN_FFP_DISABLED, 1619 (uintptr_t)disable_type); 1620 } 1621 1622 static void 1623 idm_initial_login_actions(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 1624 { 1625 ASSERT((event_ctx->iec_event == CE_LOGIN_RCV) || 1626 (event_ctx->iec_event == CE_LOGIN_SND)); 1627 1628 /* 1629 * Currently it's not clear what we would do here -- since 1630 * we went to the trouble of coding an "initial login" hook 1631 * we'll leave it in for now. Remove before integration if 1632 * it's not used for anything. 1633 */ 1634 ic->ic_state_flags |= CF_INITIAL_LOGIN; 1635 } 1636 1637 static void 1638 idm_login_success_actions(idm_conn_t *ic, idm_conn_event_ctx_t *event_ctx) 1639 { 1640 idm_pdu_t *pdu = (idm_pdu_t *)event_ctx->iec_info; 1641 iscsi_login_hdr_t *login_req = 1642 (iscsi_login_hdr_t *)pdu->isp_hdr; 1643 1644 ASSERT((event_ctx->iec_event == CE_LOGIN_SUCCESS_RCV) || 1645 (event_ctx->iec_event == CE_LOGIN_SUCCESS_SND)); 1646 1647 /* 1648 * Save off CID 1649 */ 1650 mutex_enter(&ic->ic_state_mutex); 1651 ic->ic_login_cid = ntohs(login_req->cid); 1652 ic->ic_login_info_valid = B_TRUE; 1653 1654 mutex_exit(&ic->ic_state_mutex); 1655 } 1656