kernel/comstar/port/iscsit/iscsit_sess.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  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
  24  */
  25
  26 #include <sys/cpuvar.h>
  27 #include <sys/types.h>
  28 #include <sys/conf.h>
  29 #include <sys/file.h>
  30 #include <sys/ddi.h>
  31 #include <sys/sunddi.h>
  32 #include <sys/modctl.h>
  33 #include <sys/sysmacros.h>
  34 #include <sys/scsi/generic/persist.h>
  35
  36 #include <sys/socket.h>
  37 #include <sys/strsubr.h>
  38 #include <sys/note.h>
  39 #include <sys/sdt.h>
  40
  41 #include <sys/stmf.h>
  42 #include <sys/stmf_ioctl.h>
  43 #include <sys/portif.h>
  44 #include <sys/idm/idm.h>
  45
  46 #define ISCSIT_SESS_SM_STRINGS
  47 #include "iscsit.h"
  48
  49 typedef struct {
  50         list_node_t             se_ctx_node;
  51         iscsit_session_event_t  se_ctx_event;
  52         iscsit_conn_t           *se_event_data;
  53 } sess_event_ctx_t;
  54
  55 static void
  56 sess_sm_event_locked(iscsit_sess_t *ist, iscsit_session_event_t event,
  57 iscsit_conn_t *ict);
  58
  59 static void
  60 sess_sm_event_dispatch(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  61
  62 static void
  63 sess_sm_q1_free(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  64
  65 static void
  66 sess_sm_q2_active(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  67
  68 static void
  69 sess_sm_q3_logged_in(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  70
  71 static void
  72 sess_sm_q4_failed(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  73
  74 static void
  75 sess_sm_q5_continue(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  76
  77 static void
  78 sess_sm_q6_done(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  79
  80 static void
  81 sess_sm_q7_error(iscsit_sess_t *ist, sess_event_ctx_t *ctx);
  82
  83 static void
  84 sess_sm_new_state(iscsit_sess_t *ist, sess_event_ctx_t *ctx,
  85     iscsit_session_state_t new_state);
  86
  87 static int
  88 iscsit_task_itt_compare(const void *void_task1, const void *void_task2);
  89
  90 static uint16_t
  91 iscsit_tsih_alloc(void)
  92 {
  93         uintptr_t result;
  94
  95         result = (uintptr_t)vmem_alloc(iscsit_global.global_tsih_pool,
  96             1, VM_NOSLEEP | VM_NEXTFIT);
  97
  98         /* ISCSI_UNSPEC_TSIH (0) indicates failure */
  99         if (result > ISCSI_MAX_TSIH) {
 100                 vmem_free(iscsit_global.global_tsih_pool, (void *)result, 1);
 101                 result = ISCSI_UNSPEC_TSIH;
 102         }
 103
 104         return ((uint16_t)result);
 105 }
 106
 107 static void
 108 iscsit_tsih_free(uint16_t tsih)
 109 {
 110         vmem_free(iscsit_global.global_tsih_pool, (void *)(uintptr_t)tsih, 1);
 111 }
 112
 113
 114 iscsit_sess_t *
 115 iscsit_sess_create(iscsit_tgt_t *tgt, iscsit_conn_t *ict,
 116     uint32_t cmdsn, uint8_t *isid, uint16_t tag,
 117     char *initiator_name, char *target_name,
 118     uint8_t *error_class, uint8_t *error_detail)
 119 {
 120         iscsit_sess_t *result;
 121
 122         *error_class = ISCSI_STATUS_CLASS_SUCCESS;
 123
 124         /*
 125          * Even if this session create "fails" for some reason we still need
 126          * to return a valid session pointer so that we can send the failed
 127          * login response.
 128          */
 129         result = kmem_zalloc(sizeof (*result), KM_SLEEP);
 130
 131         /* Allocate TSIH */
 132         if ((result->ist_tsih = iscsit_tsih_alloc()) == ISCSI_UNSPEC_TSIH) {
 133                 /* Out of TSIH's */
 134                 *error_class = ISCSI_STATUS_CLASS_TARGET_ERR;
 135                 *error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
 136                 /*
 137                  * Continue initializing this session so we can use it
 138                  * to complete the login process.
 139                  */
 140         }
 141
 142         idm_sm_audit_init(&result->ist_state_audit);
 143         mutex_init(&result->ist_sn_mutex, NULL, MUTEX_DEFAULT, NULL);
 144         mutex_init(&result->ist_mutex, NULL, MUTEX_DEFAULT, NULL);
 145         cv_init(&result->ist_cv, NULL, CV_DEFAULT, NULL);
 146         list_create(&result->ist_events, sizeof (sess_event_ctx_t),
 147             offsetof(sess_event_ctx_t, se_ctx_node));
 148         list_create(&result->ist_conn_list, sizeof (iscsit_conn_t),
 149             offsetof(iscsit_conn_t, ict_sess_ln));
 150         avl_create(&result->ist_task_list, iscsit_task_itt_compare,
 151             sizeof (iscsit_task_t), offsetof(iscsit_task_t, it_sess_ln));
 152         result->ist_rxpdu_queue = kmem_zalloc(sizeof (iscsit_cbuf_t), KM_SLEEP);
 153         result->ist_state = SS_Q1_FREE;
 154         result->ist_last_state = SS_Q1_FREE;
 155         bcopy(isid, result->ist_isid, ISCSI_ISID_LEN);
 156         result->ist_tpgt_tag = tag;
 157
 158         result->ist_tgt = tgt;
 159         /*
 160          * cmdsn/expcmdsn do not advance during login phase.
 161          */
 162         result->ist_expcmdsn = cmdsn;
 163         result->ist_maxcmdsn = result->ist_expcmdsn + 1;
 164
 165         result->ist_initiator_name =
 166             kmem_alloc(strlen(initiator_name) + 1, KM_SLEEP);
 167         (void) strcpy(result->ist_initiator_name, initiator_name);
 168         if (target_name) {
 169                 /* A discovery session might not have a target name */
 170                 result->ist_target_name =
 171                     kmem_alloc(strlen(target_name) + 1, KM_SLEEP);
 172                 (void) strcpy(result->ist_target_name, target_name);
 173         }
 174         idm_refcnt_init(&result->ist_refcnt, result);
 175
 176         /* Login code will fill in ist_stmf_sess if necessary */
 177
 178         if (*error_class == ISCSI_STATUS_CLASS_SUCCESS) {
 179                 /*
 180                  * Make sure the service is still enabled and if so get a global
 181                  * hold to represent this session.
 182                  */
 183                 mutex_enter(&iscsit_global.global_state_mutex);
 184                 if (iscsit_global.global_svc_state == ISE_ENABLED) {
 185                         iscsit_global_hold();
 186                         mutex_exit(&iscsit_global.global_state_mutex);
 187
 188                         /*
 189                          * Kick session state machine (also binds connection
 190                          * to session)
 191                          */
 192                         iscsit_sess_sm_event(result, SE_CONN_IN_LOGIN, ict);
 193
 194                         *error_class = ISCSI_STATUS_CLASS_SUCCESS;
 195                 } else {
 196                         mutex_exit(&iscsit_global.global_state_mutex);
 197                         *error_class = ISCSI_STATUS_CLASS_TARGET_ERR;
 198                         *error_detail = ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE;
 199                 }
 200         }
 201
 202         /*
 203          * As noted above we must return a session pointer even if something
 204          * failed.  The resources will get freed later.
 205          */
 206         return (result);
 207 }
 208
 209 static void
 210 iscsit_sess_unref(void *ist_void)
 211 {
 212         iscsit_sess_t *ist = ist_void;
 213         stmf_scsi_session_t *iss;
 214
 215         /*
 216          * State machine has run to completion, destroy session
 217          *
 218          * If we have an associated STMF session we should clean it
 219          * up now.
 220          *
 221          * This session is no longer associated with a target at this
 222          * point so don't touch the target.
 223          */
 224         mutex_enter(&ist->ist_mutex);
 225         ASSERT(ist->ist_conn_count == 0);
 226         iss = ist->ist_stmf_sess;
 227         if (iss != NULL) {
 228                 stmf_deregister_scsi_session(ist->ist_lport, iss);
 229                 kmem_free(iss->ss_rport_id, sizeof (scsi_devid_desc_t) +
 230                     strlen(ist->ist_initiator_name) + 1);
 231                 stmf_remote_port_free(iss->ss_rport);
 232                 if (iss->ss_rport_alias)
 233                         strfree(iss->ss_rport_alias);
 234                 stmf_free(iss);
 235         }
 236         mutex_exit(&ist->ist_mutex);
 237
 238         iscsit_sess_destroy(ist);
 239         iscsit_global_rele();
 240 }
 241
 242 void
 243 iscsit_sess_destroy(iscsit_sess_t *ist)
 244 {
 245         idm_refcnt_destroy(&ist->ist_refcnt);
 246         if (ist->ist_initiator_name)
 247                 kmem_free(ist->ist_initiator_name,
 248                     strlen(ist->ist_initiator_name) + 1);
 249         if (ist->ist_initiator_alias)
 250                 kmem_free(ist->ist_initiator_alias,
 251                     strlen(ist->ist_initiator_alias) + 1);
 252         if (ist->ist_target_name)
 253                 kmem_free(ist->ist_target_name,
 254                     strlen(ist->ist_target_name) + 1);
 255         if (ist->ist_target_alias)
 256                 kmem_free(ist->ist_target_alias,
 257                     strlen(ist->ist_target_alias) + 1);
 258         avl_destroy(&ist->ist_task_list);
 259         kmem_free(ist->ist_rxpdu_queue, sizeof (iscsit_cbuf_t));
 260         list_destroy(&ist->ist_conn_list);
 261         list_destroy(&ist->ist_events);
 262         cv_destroy(&ist->ist_cv);
 263         mutex_destroy(&ist->ist_mutex);
 264         mutex_destroy(&ist->ist_sn_mutex);
 265         kmem_free(ist, sizeof (*ist));
 266 }
 267
 268 void
 269 iscsit_sess_close(iscsit_sess_t *ist)
 270 {
 271         iscsit_conn_t *ict;
 272
 273         mutex_enter(&ist->ist_mutex);
 274         /*
 275          * Note in the session state that we are forcing this session
 276          * to close so that the session state machine can avoid
 277          * pointless delays like transitions to SS_Q4_FAILED state.
 278          */
 279         ist->ist_admin_close = B_TRUE;
 280         if (ist->ist_state == SS_Q3_LOGGED_IN) {
 281                 for (ict = list_head(&ist->ist_conn_list);
 282                     ict != NULL;
 283                     ict = list_next(&ist->ist_conn_list, ict)) {
 284                         iscsit_send_async_event(ict,
 285                             ISCSI_ASYNC_EVENT_REQUEST_LOGOUT);
 286                 }
 287         }
 288         mutex_exit(&ist->ist_mutex);
 289 }
 290
 291
 292 void
 293 iscsit_sess_bind_conn(iscsit_sess_t *ist, iscsit_conn_t *ict)
 294 {
 295         iscsit_conn_hold(ict);
 296         iscsit_sess_hold(ist);
 297         ict->ict_sess = ist;
 298         mutex_enter(&ist->ist_mutex);
 299         ist->ist_conn_count++;
 300         list_insert_tail(&ist->ist_conn_list, ict);
 301         mutex_exit(&ist->ist_mutex);
 302 }
 303
 304 void
 305 iscsit_sess_unbind_conn(iscsit_sess_t *ist, iscsit_conn_t *ict)
 306 {
 307         mutex_enter(&ist->ist_mutex);
 308         list_remove(&ist->ist_conn_list, ict);
 309         ist->ist_conn_count--;
 310         mutex_exit(&ist->ist_mutex);
 311         iscsit_sess_rele(ist);
 312         iscsit_conn_rele(ict);
 313 }
 314
 315 void
 316 iscsit_sess_hold(iscsit_sess_t *ist)
 317 {
 318         idm_refcnt_hold(&ist->ist_refcnt);
 319 }
 320
 321 void
 322 iscsit_sess_rele(iscsit_sess_t *ist)
 323 {
 324         idm_refcnt_rele(&ist->ist_refcnt);
 325 }
 326
 327 idm_status_t
 328 iscsit_sess_check_hold(iscsit_sess_t *ist)
 329 {
 330         mutex_enter(&ist->ist_mutex);
 331         if (ist->ist_state != SS_Q6_DONE &&
 332             ist->ist_state != SS_Q7_ERROR) {
 333                 idm_refcnt_hold(&ist->ist_refcnt);
 334                 mutex_exit(&ist->ist_mutex);
 335                 return (IDM_STATUS_SUCCESS);
 336         }
 337         mutex_exit(&ist->ist_mutex);
 338         return (IDM_STATUS_FAIL);
 339 }
 340
 341 iscsit_conn_t *
 342 iscsit_sess_lookup_conn(iscsit_sess_t *ist, uint16_t cid)
 343 {
 344         iscsit_conn_t *result;
 345
 346         mutex_enter(&ist->ist_mutex);
 347         for (result = list_head(&ist->ist_conn_list);
 348             result != NULL;
 349             result = list_next(&ist->ist_conn_list, result)) {
 350                 if (result->ict_cid == cid) {
 351                         iscsit_conn_hold(result);
 352                         mutex_exit(&ist->ist_mutex);
 353                         return (result);
 354                 }
 355         }
 356         mutex_exit(&ist->ist_mutex);
 357
 358         return (NULL);
 359 }
 360
 361 iscsit_sess_t *
 362 iscsit_sess_reinstate(iscsit_tgt_t *tgt, iscsit_sess_t *ist, iscsit_conn_t *ict,
 363     uint8_t *error_class, uint8_t *error_detail)
 364 {
 365         iscsit_sess_t *new_sess;
 366
 367         mutex_enter(&ist->ist_mutex);
 368
 369         /*
 370          * Session reinstatement replaces a current session with a new session.
 371          * The new session will have the same ISID as the existing session.
 372          */
 373         new_sess = iscsit_sess_create(tgt, ict, 0,
 374             ist->ist_isid, ist->ist_tpgt_tag,
 375             ist->ist_initiator_name, ist->ist_target_name,
 376             error_class, error_detail);
 377         ASSERT(new_sess != NULL);
 378
 379         /* Copy additional fields from original session */
 380         new_sess->ist_expcmdsn = ist->ist_expcmdsn;
 381         new_sess->ist_maxcmdsn = ist->ist_expcmdsn + 1;
 382
 383         if (ist->ist_state != SS_Q6_DONE &&
 384             ist->ist_state != SS_Q7_ERROR) {
 385                 /*
 386                  * Generate reinstate event
 387                  */
 388                 sess_sm_event_locked(ist, SE_SESSION_REINSTATE, NULL);
 389         }
 390         mutex_exit(&ist->ist_mutex);
 391
 392         return (new_sess);
 393 }
 394
 395 int
 396 iscsit_sess_avl_compare(const void *void_sess1, const void *void_sess2)
 397 {
 398         const iscsit_sess_t     *sess1 = void_sess1;
 399         const iscsit_sess_t     *sess2 = void_sess2;
 400         int                     result;
 401
 402         /*
 403          * Sort by initiator name, then ISID then portal group tag
 404          */
 405         result = strcmp(sess1->ist_initiator_name, sess2->ist_initiator_name);
 406         if (result < 0) {
 407                 return (-1);
 408         } else if (result > 0) {
 409                 return (1);
 410         }
 411
 412         /*
 413          * Initiator names match, compare ISIDs
 414          */
 415         result = memcmp(sess1->ist_isid, sess2->ist_isid, ISCSI_ISID_LEN);
 416         if (result < 0) {
 417                 return (-1);
 418         } else if (result > 0) {
 419                 return (1);
 420         }
 421
 422         /*
 423          * ISIDs match, compare portal group tags
 424          */
 425         if (sess1->ist_tpgt_tag < sess2->ist_tpgt_tag) {
 426                 return (-1);
 427         } else if (sess1->ist_tpgt_tag > sess2->ist_tpgt_tag) {
 428                 return (1);
 429         }
 430
 431         /*
 432          * Portal group tags match, compare TSIHs
 433          */
 434         if (sess1->ist_tsih < sess2->ist_tsih) {
 435                 return (-1);
 436         } else if (sess1->ist_tsih > sess2->ist_tsih) {
 437                 return (1);
 438         }
 439
 440         /*
 441          * Sessions match
 442          */
 443         return (0);
 444 }
 445
 446 int
 447 iscsit_task_itt_compare(const void *void_task1, const void *void_task2)
 448 {
 449         const iscsit_task_t     *task1 = void_task1;
 450         const iscsit_task_t     *task2 = void_task2;
 451
 452         if (task1->it_itt < task2->it_itt)
 453                 return (-1);
 454         else if (task1->it_itt > task2->it_itt)
 455                 return (1);
 456
 457         return (0);
 458 }
 459
 460 /*
 461  * State machine
 462  */
 463
 464 void
 465 iscsit_sess_sm_event(iscsit_sess_t *ist, iscsit_session_event_t event,
 466     iscsit_conn_t *ict)
 467 {
 468         mutex_enter(&ist->ist_mutex);
 469         sess_sm_event_locked(ist, event, ict);
 470         mutex_exit(&ist->ist_mutex);
 471 }
 472
 473 static void
 474 sess_sm_event_locked(iscsit_sess_t *ist, iscsit_session_event_t event,
 475     iscsit_conn_t *ict)
 476 {
 477         sess_event_ctx_t *ctx;
 478
 479         iscsit_sess_hold(ist);
 480
 481         ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP);
 482
 483         ctx->se_ctx_event = event;
 484         ctx->se_event_data = ict;
 485
 486         list_insert_tail(&ist->ist_events, ctx);
 487         /*
 488          * Use the ist_sm_busy to keep the state machine single threaded.
 489          * This also serves as recursion avoidance since this flag will
 490          * always be set if we call login_sm_event from within the
 491          * state machine code.
 492          */
 493         if (!ist->ist_sm_busy) {
 494                 ist->ist_sm_busy = B_TRUE;
 495                 while (!list_is_empty(&ist->ist_events)) {
 496                         ctx = list_head(&ist->ist_events);
 497                         list_remove(&ist->ist_events, ctx);
 498                         idm_sm_audit_event(&ist->ist_state_audit,
 499                             SAS_ISCSIT_SESS, (int)ist->ist_state,
 500                             (int)ctx->se_ctx_event, (uintptr_t)ict);
 501                         mutex_exit(&ist->ist_mutex);
 502                         sess_sm_event_dispatch(ist, ctx);
 503                         mutex_enter(&ist->ist_mutex);
 504                 }
 505                 ist->ist_sm_busy = B_FALSE;
 506
 507         }
 508
 509         iscsit_sess_rele(ist);
 510 }
 511
 512 static void
 513 sess_sm_event_dispatch(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 514 {
 515         iscsit_conn_t   *ict;
 516
 517         DTRACE_PROBE2(session__event, iscsit_sess_t *, ist,
 518             sess_event_ctx_t *, ctx);
 519
 520         IDM_SM_LOG(CE_NOTE, "sess_sm_event_dispatch: sess %p event %s(%d)",
 521             (void *)ist, iscsit_se_name[ctx->se_ctx_event], ctx->se_ctx_event);
 522
 523         /* State independent actions */
 524         switch (ctx->se_ctx_event) {
 525         case SE_CONN_IN_LOGIN:
 526                 ict = ctx->se_event_data;
 527                 iscsit_sess_bind_conn(ist, ict);
 528                 break;
 529         case SE_CONN_FAIL:
 530                 ict = ctx->se_event_data;
 531                 iscsit_sess_unbind_conn(ist, ict);
 532                 break;
 533         }
 534
 535         /* State dependent actions */
 536         switch (ist->ist_state) {
 537         case SS_Q1_FREE:
 538                 sess_sm_q1_free(ist, ctx);
 539                 break;
 540         case SS_Q2_ACTIVE:
 541                 sess_sm_q2_active(ist, ctx);
 542                 break;
 543         case SS_Q3_LOGGED_IN:
 544                 sess_sm_q3_logged_in(ist, ctx);
 545                 break;
 546         case SS_Q4_FAILED:
 547                 sess_sm_q4_failed(ist, ctx);
 548                 break;
 549         case SS_Q5_CONTINUE:
 550                 sess_sm_q5_continue(ist, ctx);
 551                 break;
 552         case SS_Q6_DONE:
 553                 sess_sm_q6_done(ist, ctx);
 554                 break;
 555         case SS_Q7_ERROR:
 556                 sess_sm_q7_error(ist, ctx);
 557                 break;
 558         default:
 559                 ASSERT(0);
 560                 break;
 561         }
 562
 563         kmem_free(ctx, sizeof (*ctx));
 564 }
 565
 566 static void
 567 sess_sm_q1_free(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 568 {
 569         switch (ctx->se_ctx_event) {
 570         case SE_CONN_IN_LOGIN:
 571                 /* N1 */
 572                 sess_sm_new_state(ist, ctx, SS_Q2_ACTIVE);
 573                 break;
 574         default:
 575                 ASSERT(0);
 576                 break;
 577         }
 578 }
 579
 580
 581 static void
 582 sess_sm_q2_active(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 583 {
 584         iscsit_conn_t   *ict;
 585
 586         switch (ctx->se_ctx_event) {
 587         case SE_CONN_LOGGED_IN:
 588                 /* N2 track FFP connections */
 589                 ist->ist_ffp_conn_count++;
 590                 sess_sm_new_state(ist, ctx, SS_Q3_LOGGED_IN);
 591                 break;
 592         case SE_CONN_IN_LOGIN:
 593                 /* N2.1, don't care stay in this state */
 594                 break;
 595         case SE_CONN_FAIL:
 596                 /* N9 */
 597                 sess_sm_new_state(ist, ctx, SS_Q7_ERROR);
 598                 break;
 599         case SE_SESSION_REINSTATE:
 600                 /* N11 */
 601                 /*
 602                  * Shutdown the iSCSI connections by
 603                  * sending an implicit logout to all
 604                  * the IDM connections and transition
 605                  * the session to SS_Q6_DONE state.
 606                  */
 607                 mutex_enter(&ist->ist_mutex);
 608                 for (ict = list_head(&ist->ist_conn_list);
 609                     ict != NULL;
 610                     ict = list_next(&ist->ist_conn_list, ict)) {
 611                         iscsit_conn_logout(ict);
 612                 }
 613                 mutex_exit(&ist->ist_mutex);
 614                 sess_sm_new_state(ist, ctx, SS_Q6_DONE);
 615                 break;
 616         default:
 617                 ASSERT(0);
 618                 break;
 619         }
 620 }
 621
 622 static void
 623 sess_sm_q3_logged_in(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 624 {
 625         iscsit_conn_t   *ict;
 626
 627         switch (ctx->se_ctx_event) {
 628         case SE_CONN_IN_LOGIN:
 629         case SE_CONN_FAIL:
 630                 /* N2.2, don't care */
 631                 break;
 632         case SE_CONN_LOGGED_IN:
 633                 /* N2.2, track FFP connections */
 634                 ist->ist_ffp_conn_count++;
 635                 break;
 636         case SE_CONN_FFP_FAIL:
 637         case SE_CONN_FFP_DISABLE:
 638                 /*
 639                  * Event data from event context is the associated connection
 640                  * which in this case happens to be the last FFP connection
 641                  * for the session.  In certain cases we need to refer
 642                  * to this last valid connection (i.e. RFC3720 section 12.16)
 643                  * so we'll save off a pointer here for later use.
 644                  */
 645                 ASSERT(ist->ist_ffp_conn_count >= 1);
 646                 ist->ist_failed_conn = (iscsit_conn_t *)ctx->se_event_data;
 647                 ist->ist_ffp_conn_count--;
 648                 if (ist->ist_ffp_conn_count == 0) {
 649                         /*
 650                          * N5(fail) or N3(disable)
 651                          *
 652                          * If the event is SE_CONN_FFP_FAIL but we are
 653                          * in the midst of an administrative session close
 654                          * because of a service or target offline then
 655                          * there is no need to go to "failed" state.
 656                          */
 657                         sess_sm_new_state(ist, ctx,
 658                             ((ctx->se_ctx_event == SE_CONN_FFP_DISABLE) ||
 659                             (ist->ist_admin_close)) ?
 660                             SS_Q6_DONE : SS_Q4_FAILED);
 661                 }
 662                 break;
 663         case SE_SESSION_CLOSE:
 664         case SE_SESSION_REINSTATE:
 665                 /* N3 */
 666                 mutex_enter(&ist->ist_mutex);
 667                 if (ctx->se_ctx_event == SE_SESSION_CLOSE) {
 668                         ASSERT(ist->ist_ffp_conn_count >= 1);
 669                         ist->ist_ffp_conn_count--;
 670                 }
 671                 for (ict = list_head(&ist->ist_conn_list);
 672                     ict != NULL;
 673                     ict = list_next(&ist->ist_conn_list, ict)) {
 674                         if ((ctx->se_ctx_event == SE_SESSION_CLOSE) &&
 675                             ((iscsit_conn_t *)ctx->se_event_data == ict)) {
 676                                 /*
 677                                  * Skip this connection since it will
 678                                  * see the logout response
 679                                  */
 680                                 continue;
 681                         }
 682                         iscsit_conn_logout(ict);
 683                 }
 684                 mutex_exit(&ist->ist_mutex);
 685
 686                 sess_sm_new_state(ist, ctx, SS_Q6_DONE);
 687                 break;
 688         default:
 689                 ASSERT(0);
 690                 break;
 691         }
 692 }
 693
 694 static void
 695 sess_sm_timeout(void *arg)
 696 {
 697         iscsit_sess_t *ist = arg;
 698
 699         iscsit_sess_sm_event(ist, SE_SESSION_TIMEOUT, NULL);
 700 }
 701
 702 static void
 703 sess_sm_q4_failed(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 704 {
 705         /* Session timer must not be running when we leave this event */
 706         switch (ctx->se_ctx_event) {
 707         case SE_CONN_IN_LOGIN:
 708                 /* N7 */
 709                 sess_sm_new_state(ist, ctx, SS_Q5_CONTINUE);
 710                 break;
 711         case SE_SESSION_REINSTATE:
 712                 /* N6 */
 713                 (void) untimeout(ist->ist_state_timeout);
 714                 /*FALLTHROUGH*/
 715         case SE_SESSION_TIMEOUT:
 716                 /* N6 */
 717                 sess_sm_new_state(ist, ctx, SS_Q6_DONE);
 718                 break;
 719         case SE_CONN_FAIL:
 720                 /* Don't care */
 721                 break;
 722         default:
 723                 ASSERT(0);
 724                 break;
 725         }
 726 }
 727
 728 static void
 729 sess_sm_q5_continue(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 730 {
 731         switch (ctx->se_ctx_event) {
 732         case SE_CONN_FAIL:
 733                 /* N5 */
 734                 sess_sm_new_state(ist, ctx, SS_Q4_FAILED);
 735                 break;
 736         case SE_CONN_LOGGED_IN:
 737                 /* N10 */
 738                 sess_sm_new_state(ist, ctx, SS_Q3_LOGGED_IN);
 739                 break;
 740         case SE_SESSION_REINSTATE:
 741                 /* N11 */
 742                 sess_sm_new_state(ist, ctx, SS_Q6_DONE);
 743                 break;
 744         default:
 745                 ASSERT(0);
 746                 break;
 747         }
 748 }
 749
 750 static void
 751 sess_sm_q6_done(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 752 {
 753         /* Terminal state */
 754         switch (ctx->se_ctx_event) {
 755         case SE_CONN_LOGGED_IN:
 756                 /*
 757                  * It's possible to get this event if we encountered
 758                  * an SE_SESSION_REINSTATE_EVENT while we were in
 759                  * SS_Q2_ACTIVE state.  If so we want to update
 760                  * ist->ist_ffp_conn_count because we know an
 761                  * SE_CONN_FFP_FAIL or SE_CONN_FFP_DISABLE is on the
 762                  * way.
 763                  */
 764                 ist->ist_ffp_conn_count++;
 765                 break;
 766         case SE_CONN_FFP_FAIL:
 767         case SE_CONN_FFP_DISABLE:
 768                 ASSERT(ist->ist_ffp_conn_count >= 1);
 769                 ist->ist_ffp_conn_count--;
 770                 break;
 771         case SE_CONN_FAIL:
 772                 if (ist->ist_conn_count == 0) {
 773                         idm_refcnt_async_wait_ref(&ist->ist_refcnt,
 774                             &iscsit_sess_unref);
 775                 }
 776                 break;
 777         default:
 778                 break;
 779         }
 780 }
 781
 782 static void
 783 sess_sm_q7_error(iscsit_sess_t *ist, sess_event_ctx_t *ctx)
 784 {
 785         /* Terminal state */
 786         switch (ctx->se_ctx_event) {
 787         case SE_CONN_FAIL:
 788                 if (ist->ist_conn_count == 0) {
 789                         idm_refcnt_async_wait_ref(&ist->ist_refcnt,
 790                             &iscsit_sess_unref);
 791                 }
 792                 break;
 793         default:
 794                 break;
 795         }
 796 }
 797
 798 static void
 799 sess_sm_new_state(iscsit_sess_t *ist, sess_event_ctx_t *ctx,
 800     iscsit_session_state_t new_state)
 801 {
 802         int t2r_secs;
 803
 804         /*
 805          * Validate new state
 806          */
 807         ASSERT(new_state != SS_UNDEFINED);
 808         ASSERT3U(new_state, <, SS_MAX_STATE);
 809
 810         new_state = (new_state < SS_MAX_STATE) ?
 811             new_state : SS_UNDEFINED;
 812
 813         IDM_SM_LOG(CE_NOTE, "sess_sm_new_state: sess %p, evt %s(%d), "
 814             "%s(%d) --> %s(%d)\n", (void *) ist,
 815             iscsit_se_name[ctx->se_ctx_event], ctx->se_ctx_event,
 816             iscsit_ss_name[ist->ist_state], ist->ist_state,
 817             iscsit_ss_name[new_state], new_state);
 818
 819         DTRACE_PROBE3(sess__state__change,
 820             iscsit_sess_t *, ist, sess_event_ctx_t *, ctx,
 821             iscsit_session_state_t, new_state);
 822
 823         mutex_enter(&ist->ist_mutex);
 824         idm_sm_audit_state_change(&ist->ist_state_audit, SAS_ISCSIT_SESS,
 825             (int)ist->ist_state, (int)new_state);
 826         ist->ist_last_state = ist->ist_state;
 827         ist->ist_state = new_state;
 828         mutex_exit(&ist->ist_mutex);
 829
 830         switch (ist->ist_state) {
 831         case SS_Q1_FREE:
 832                 break;
 833         case SS_Q2_ACTIVE:
 834                 iscsit_tgt_bind_sess(ist->ist_tgt, ist);
 835                 break;
 836         case SS_Q3_LOGGED_IN:
 837                 break;
 838         case SS_Q4_FAILED:
 839                 t2r_secs =
 840                     ist->ist_failed_conn->ict_op.op_default_time_2_retain;
 841                 ist->ist_state_timeout = timeout(sess_sm_timeout, ist,
 842                     drv_usectohz(t2r_secs*1000000));
 843                 break;
 844         case SS_Q5_CONTINUE:
 845                 break;
 846         case SS_Q6_DONE:
 847         case SS_Q7_ERROR:
 848                 /*
 849                  * We won't need our TSIH anymore and it represents an
 850                  * implicit reference to the global TSIH pool.  Get rid
 851                  * of it.
 852                  */
 853                 if (ist->ist_tsih != ISCSI_UNSPEC_TSIH) {
 854                         iscsit_tsih_free(ist->ist_tsih);
 855                 }
 856
 857                 /*
 858                  * We don't want this session to show up anymore so unbind
 859                  * it now.  After this call this session cannot have any
 860                  * references outside itself (implicit or explicit).
 861                  */
 862                 iscsit_tgt_unbind_sess(ist->ist_tgt, ist);
 863
 864                 /*
 865                  * If we have more connections bound then more events
 866                  * are comming so don't wait for idle yet.
 867                  */
 868                 if (ist->ist_conn_count == 0) {
 869                         idm_refcnt_async_wait_ref(&ist->ist_refcnt,
 870                             &iscsit_sess_unref);
 871                 }
 872                 break;
 873         default:
 874                 ASSERT(0);
 875                 /*NOTREACHED*/
 876         }
 877 }