usr/src/uts/common/io/idm/idm_conn_sm.c

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