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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  * fcsm - ULP Module for Fibre Channel SAN Management
  28  */
  29 
  30 #include <sys/types.h>
  31 #include <sys/file.h>
  32 #include <sys/kmem.h>
  33 #include <sys/scsi/scsi.h>
  34 #include <sys/var.h>
  35 #include <sys/byteorder.h>
  36 #include <sys/fibre-channel/fc.h>
  37 #include <sys/fibre-channel/impl/fc_ulpif.h>
  38 #include <sys/fibre-channel/ulp/fcsm.h>
  39 
  40 /* Definitions */
  41 #define FCSM_VERSION            "20090729-1.28"
  42 #define FCSM_NAME_VERSION       "SunFC FCSM v" FCSM_VERSION
  43 
  44 /* Global Variables */
  45 static char             fcsm_name[] = "FCSM";
  46 static void             *fcsm_state = NULL;
  47 static kmutex_t         fcsm_global_mutex;
  48 static uint32_t         fcsm_flag = FCSM_IDLE;
  49 static dev_info_t       *fcsm_dip = NULL;
  50 static fcsm_t           *fcsm_port_head = NULL;
  51 static kmem_cache_t     *fcsm_job_cache = NULL;
  52 static int              fcsm_num_attaching = 0;
  53 static int              fcsm_num_detaching = 0;
  54 static int              fcsm_detached = 0;
  55 
  56 static int              fcsm_max_cmd_retries = FCSM_MAX_CMD_RETRIES;
  57 static int              fcsm_retry_interval = FCSM_RETRY_INTERVAL;
  58 static int              fcsm_retry_ticker = FCSM_RETRY_TICKER;
  59 static int              fcsm_offline_ticker = FCSM_OFFLINE_TICKER;
  60 static int              fcsm_max_job_retries = FCSM_MAX_JOB_RETRIES;
  61 static clock_t          fcsm_retry_ticks;
  62 static clock_t          fcsm_offline_ticks;
  63 
  64 
  65 
  66 #ifdef DEBUG
  67 uint32_t                fcsm_debug = (SMDL_TRACE | SMDL_IO |
  68     SMDL_ERR | SMDL_INFO);
  69 #endif
  70 
  71 
  72 /* Character/Block entry points */
  73 struct cb_ops   fcsm_cb_ops = {
  74         fcsm_open,      /* open */
  75         fcsm_close,     /* close */
  76         nodev,          /* strategy */
  77         nodev,          /* print */
  78         nodev,          /* dump */
  79         nodev,          /* read */
  80         nodev,          /* write */
  81         fcsm_ioctl,     /* ioctl */
  82         nodev,          /* devmap */
  83         nodev,          /* mmap */
  84         nodev,          /* segmap */
  85         nochpoll,       /* poll */
  86         ddi_prop_op,
  87         NULL,           /* streams info */
  88         D_NEW | D_MP,
  89         CB_REV,
  90         nodev,          /* aread */
  91         nodev           /* awrite */
  92 };
  93 
  94 struct dev_ops fcsm_ops = {
  95         DEVO_REV,
  96         0,              /* refcnt */
  97         fcsm_getinfo,   /* get info */
  98         nulldev,        /* identify (obsolete) */
  99         nulldev,        /* probe (not required for self-identifying devices) */
 100         fcsm_attach,    /* attach */
 101         fcsm_detach,    /* detach */
 102         nodev,          /* reset */
 103         &fcsm_cb_ops,       /* char/block entry points structure for leaf drivers */
 104         NULL,           /* bus operations for nexus driver */
 105         NULL            /* power management */
 106 };
 107 
 108 
 109 struct modldrv modldrv = {
 110         &mod_driverops,
 111         FCSM_NAME_VERSION,
 112         &fcsm_ops
 113 };
 114 
 115 struct modlinkage modlinkage = {
 116         MODREV_1,
 117         { &modldrv, NULL }
 118 };
 119 
 120 static fc_ulp_modinfo_t fcsm_modinfo = {
 121         &fcsm_modinfo,              /* ulp_handle */
 122         FCTL_ULP_MODREV_4,      /* ulp_rev */
 123         FC_TYPE_FC_SERVICES,    /* ulp_type */
 124         fcsm_name,              /* ulp_name */
 125         0,                      /* ulp_statec_mask: get all statec callbacks */
 126         fcsm_port_attach,       /* ulp_port_attach */
 127         fcsm_port_detach,       /* ulp_port_detach */
 128         fcsm_port_ioctl,        /* ulp_port_ioctl */
 129         fcsm_els_cb,            /* ulp_els_callback */
 130         fcsm_data_cb,           /* ulp_data_callback */
 131         fcsm_statec_cb          /* ulp_statec_callback */
 132 };
 133 
 134 struct fcsm_xlat_pkt_state {
 135         uchar_t xlat_state;
 136         int     xlat_rval;
 137 } fcsm_xlat_pkt_state [] = {
 138         { FC_PKT_SUCCESS,               FC_SUCCESS },
 139         { FC_PKT_REMOTE_STOP,           FC_FAILURE },
 140         { FC_PKT_LOCAL_RJT,             FC_TRANSPORT_ERROR },
 141         { FC_PKT_NPORT_RJT,             FC_PREJECT },
 142         { FC_PKT_FABRIC_RJT,            FC_FREJECT },
 143         { FC_PKT_LOCAL_BSY,             FC_TRAN_BUSY },
 144         { FC_PKT_TRAN_BSY,              FC_TRAN_BUSY },
 145         { FC_PKT_NPORT_BSY,             FC_PBUSY },
 146         { FC_PKT_FABRIC_BSY,            FC_FBUSY },
 147         { FC_PKT_LS_RJT,                FC_PREJECT },
 148         { FC_PKT_BA_RJT,                FC_PREJECT },
 149         { FC_PKT_TIMEOUT,               FC_FAILURE },
 150         { FC_PKT_FS_RJT,                FC_FAILURE },
 151         { FC_PKT_TRAN_ERROR,            FC_TRANSPORT_ERROR },
 152         { FC_PKT_FAILURE,               FC_FAILURE },
 153         { FC_PKT_PORT_OFFLINE,          FC_OFFLINE },
 154         { FC_PKT_ELS_IN_PROGRESS,       FC_FAILURE }
 155 };
 156 
 157 struct fcsm_xlat_port_state {
 158         uint32_t        xlat_pstate;
 159         caddr_t         xlat_state_str;
 160 } fcsm_xlat_port_state [] = {
 161         { FC_STATE_OFFLINE,             "OFFLINE" },
 162         { FC_STATE_ONLINE,              "ONLINE" },
 163         { FC_STATE_LOOP,                "LOOP" },
 164         { FC_STATE_NAMESERVICE,         "NAMESERVICE" },
 165         { FC_STATE_RESET,               "RESET" },
 166         { FC_STATE_RESET_REQUESTED,     "RESET_REQUESTED" },
 167         { FC_STATE_LIP,                 "LIP" },
 168         { FC_STATE_LIP_LBIT_SET,        "LIP_LBIT_SET" },
 169         { FC_STATE_DEVICE_CHANGE,       "DEVICE_CHANGE" },
 170         { FC_STATE_TARGET_PORT_RESET,   "TARGET_PORT_RESET" }
 171 };
 172 
 173 struct fcsm_xlat_topology {
 174         uint32_t        xlat_top;
 175         caddr_t         xlat_top_str;
 176 } fcsm_xlat_topology [] = {
 177         { FC_TOP_UNKNOWN,       "UNKNOWN" },
 178         { FC_TOP_PRIVATE_LOOP,  "Private Loop" },
 179         { FC_TOP_PUBLIC_LOOP,   "Public Loop" },
 180         { FC_TOP_FABRIC,        "Fabric" },
 181         { FC_TOP_PT_PT,         "Point-to-Point" },
 182         { FC_TOP_NO_NS,         "NO_NS" }
 183 };
 184 
 185 struct fcsm_xlat_dev_type {
 186         uint32_t        xlat_type;
 187         caddr_t         xlat_str;
 188 } fcsm_xlat_dev_type [] = {
 189         { PORT_DEVICE_NOCHANGE,         "No Change" },
 190         { PORT_DEVICE_NEW,              "New" },
 191         { PORT_DEVICE_OLD,              "Old" },
 192         { PORT_DEVICE_CHANGED,          "Changed" },
 193         { PORT_DEVICE_DELETE,           "Delete" },
 194         { PORT_DEVICE_USER_LOGIN,       "User Login" },
 195         { PORT_DEVICE_USER_LOGOUT,      "User Logout" },
 196         { PORT_DEVICE_USER_CREATE,      "User Create" },
 197         { PORT_DEVICE_USER_DELETE,      "User Delete" }
 198 };
 199 
 200 int
 201 _init(void)
 202 {
 203         int             rval;
 204 
 205         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "_init"));
 206 
 207         fcsm_retry_ticks = drv_usectohz(fcsm_retry_ticker * 1000 * 1000);
 208         fcsm_offline_ticks = drv_usectohz(fcsm_offline_ticker * 1000 * 1000);
 209 
 210         if (rval = ddi_soft_state_init(&fcsm_state, sizeof (fcsm_t),
 211             FCSM_INIT_INSTANCES)) {
 212                 fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 213                     "_init: ddi_soft_state_init failed");
 214                 return (ENOMEM);
 215         }
 216 
 217         mutex_init(&fcsm_global_mutex, NULL, MUTEX_DRIVER, NULL);
 218 
 219         fcsm_job_cache = kmem_cache_create("fcsm_job_cache",
 220             sizeof (fcsm_job_t), 8, fcsm_job_cache_constructor,
 221             fcsm_job_cache_destructor, NULL, NULL, NULL, 0);
 222 
 223         if (fcsm_job_cache == NULL) {
 224                 mutex_destroy(&fcsm_global_mutex);
 225                 ddi_soft_state_fini(&fcsm_state);
 226                 return (ENOMEM);
 227         }
 228 
 229         /*
 230          * Now call fc_ulp_add to add this ULP in the transport layer
 231          * database. This will cause 'ulp_port_attach' callback function
 232          * to be called.
 233          */
 234         rval = fc_ulp_add(&fcsm_modinfo);
 235         if (rval != 0) {
 236                 switch (rval) {
 237                 case FC_ULP_SAMEMODULE:
 238                         fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 239                             "_init: FC SAN Management module is already "
 240                             "registered with transport layer");
 241                         rval = EEXIST;
 242                         break;
 243 
 244                 case FC_ULP_SAMETYPE:
 245                         fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 246                             "_init: Another module with same type 0x%x is "
 247                             "already registered with transport layer",
 248                             fcsm_modinfo.ulp_type);
 249                         rval = EEXIST;
 250                         break;
 251 
 252                 case FC_BADULP:
 253                         fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 254                             "_init: Please upgrade this module. Current "
 255                             "version 0x%x is not the most recent version",
 256                             fcsm_modinfo.ulp_rev);
 257                         rval = EIO;
 258                         break;
 259                 default:
 260                         fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 261                             "_init: fc_ulp_add failed with status 0x%x", rval);
 262                         rval = EIO;
 263                         break;
 264                 }
 265                 kmem_cache_destroy(fcsm_job_cache);
 266                 mutex_destroy(&fcsm_global_mutex);
 267                 ddi_soft_state_fini(&fcsm_state);
 268                 return (rval);
 269         }
 270 
 271         if ((rval = mod_install(&modlinkage)) != 0) {
 272                 FCSM_DEBUG(SMDL_ERR, (CE_WARN, SM_LOG, NULL, NULL,
 273                     "_init: mod_install failed with status 0x%x", rval));
 274                 (void) fc_ulp_remove(&fcsm_modinfo);
 275                 kmem_cache_destroy(fcsm_job_cache);
 276                 mutex_destroy(&fcsm_global_mutex);
 277                 ddi_soft_state_fini(&fcsm_state);
 278                 return (rval);
 279         }
 280 
 281         return (rval);
 282 }
 283 
 284 int
 285 _fini(void)
 286 {
 287         int     rval;
 288 #ifdef  DEBUG
 289         int     status;
 290 #endif /* DEBUG */
 291 
 292         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "_fini"));
 293 
 294         /*
 295          * don't start cleaning up until we know that the module remove
 296          * has worked  -- if this works, then we know that each instance
 297          * has successfully been DDI_DETACHed
 298          */
 299         if ((rval = mod_remove(&modlinkage)) != 0) {
 300                 return (rval);
 301         }
 302 
 303 #ifdef DEBUG
 304         status = fc_ulp_remove(&fcsm_modinfo);
 305         if (status != 0) {
 306                 FCSM_DEBUG(SMDL_ERR, (CE_WARN, SM_LOG, NULL, NULL,
 307                     "_fini: fc_ulp_remove failed with status 0x%x", status));
 308         }
 309 #else
 310         (void) fc_ulp_remove(&fcsm_modinfo);
 311 #endif /* DEBUG */
 312 
 313         fcsm_detached = 0;
 314 
 315         /*
 316          * It is possible to modunload fcsm manually, which will cause
 317          * a bypass of all the port_detach functionality.  We may need
 318          * to force that code path to be executed to properly clean up
 319          * in that case.
 320          */
 321         fcsm_force_port_detach_all();
 322 
 323         kmem_cache_destroy(fcsm_job_cache);
 324         mutex_destroy(&fcsm_global_mutex);
 325         ddi_soft_state_fini(&fcsm_state);
 326 
 327         return (rval);
 328 }
 329 
 330 
 331 int
 332 _info(struct modinfo *modinfop)
 333 {
 334         return (mod_info(&modlinkage, modinfop));
 335 }
 336 
 337 /* ARGSUSED */
 338 static int
 339 fcsm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 340 {
 341         int rval = DDI_FAILURE;
 342 
 343         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 344             "attach: cmd 0x%x", cmd));
 345 
 346         switch (cmd) {
 347         case DDI_ATTACH:
 348                 mutex_enter(&fcsm_global_mutex);
 349                 if (fcsm_dip != NULL) {
 350                         mutex_exit(&fcsm_global_mutex);
 351                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 352                             "attach: duplicate attach of fcsm!!"));
 353                         break;
 354                 }
 355 
 356                 fcsm_dip = dip;
 357 
 358                 /*
 359                  * The detach routine cleans up all the port instances
 360                  * i.e. it detaches all ports.
 361                  * If _fini never got called after detach, then
 362                  * perform an fc_ulp_remove() followed by fc_ulp_add()
 363                  * to ensure that port_attach callbacks are called
 364                  * again.
 365                  */
 366                 if (fcsm_detached) {
 367                         int status;
 368 
 369                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 370                             "attach: rebinding to transport driver"));
 371 
 372                         mutex_exit(&fcsm_global_mutex);
 373 
 374                         (void) fc_ulp_remove(&fcsm_modinfo);
 375 
 376                         /*
 377                          * Reset the detached flag, so that ports can attach
 378                          */
 379                         mutex_enter(&fcsm_global_mutex);
 380                         fcsm_detached = 0;
 381                         mutex_exit(&fcsm_global_mutex);
 382 
 383                         status = fc_ulp_add(&fcsm_modinfo);
 384 
 385                         if (status != 0) {
 386                                 /*
 387                                  * ULP add failed. So set the
 388                                  * detached flag again
 389                                  */
 390                                 mutex_enter(&fcsm_global_mutex);
 391                                 fcsm_detached = 1;
 392                                 mutex_exit(&fcsm_global_mutex);
 393 
 394                                 switch (status) {
 395                                 case FC_ULP_SAMEMODULE:
 396                                         fcsm_display(CE_WARN, SM_LOG, NULL,
 397                                             NULL, "attach: FC SAN Management "
 398                                             "module is already "
 399                                             "registered with transport layer");
 400                                         break;
 401 
 402                                 case FC_ULP_SAMETYPE:
 403                                         fcsm_display(CE_WARN, SM_LOG, NULL,
 404                                             NULL, "attach: Another module with "
 405                                             "same type 0x%x is already "
 406                                             "registered with transport layer",
 407                                             fcsm_modinfo.ulp_type);
 408                                         break;
 409 
 410                                 case FC_BADULP:
 411                                         fcsm_display(CE_WARN, SM_LOG, NULL,
 412                                             NULL, "attach: Please upgrade this "
 413                                             "module. Current version 0x%x is "
 414                                             "not the most recent version",
 415                                             fcsm_modinfo.ulp_rev);
 416                                         break;
 417                                 default:
 418                                         fcsm_display(CE_WARN, SM_LOG, NULL,
 419                                             NULL, "attach: fc_ulp_add failed "
 420                                             "with status 0x%x", status);
 421                                         break;
 422                                 }
 423 
 424                                 /* Return failure */
 425                                 break;
 426                         }
 427 
 428                         mutex_enter(&fcsm_global_mutex);
 429                 }
 430 
 431                 /* Create a minor node */
 432                 if (ddi_create_minor_node(fcsm_dip, "fcsm", S_IFCHR,
 433                     NULL, DDI_PSEUDO, 0) == DDI_SUCCESS) {
 434                         /* Announce presence of the device */
 435                         mutex_exit(&fcsm_global_mutex);
 436                         ddi_report_dev(dip);
 437                         rval = DDI_SUCCESS;
 438                 } else {
 439                         fcsm_dip = NULL;
 440                         mutex_exit(&fcsm_global_mutex);
 441                         fcsm_display(CE_WARN, SM_LOG_AND_CONSOLE,
 442                             NULL, NULL, "attach: create minor node failed");
 443                 }
 444                 break;
 445 
 446         case DDI_RESUME:
 447                 rval = DDI_SUCCESS;
 448                 break;
 449 
 450         default:
 451                 FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, NULL, NULL,
 452                     "attach: unknown cmd 0x%x dip 0x%p", cmd, dip));
 453                 break;
 454         }
 455 
 456         return (rval);
 457 }
 458 
 459 /* ARGSUSED */
 460 static int
 461 fcsm_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
 462 {
 463         int     instance;
 464         int     rval = DDI_SUCCESS;
 465 
 466         instance = getminor((dev_t)arg);
 467 
 468         switch (cmd) {
 469         case DDI_INFO_DEVT2INSTANCE:
 470                 *result = (void *)(long)instance; /* minor number is instance */
 471                 break;
 472 
 473         case DDI_INFO_DEVT2DEVINFO:
 474                 mutex_enter(&fcsm_global_mutex);
 475                 *result = (void *)fcsm_dip;
 476                 mutex_exit(&fcsm_global_mutex);
 477                 break;
 478 
 479         default:
 480                 rval = DDI_FAILURE;
 481                 break;
 482         }
 483 
 484         return (rval);
 485 }
 486 
 487 
 488 /* ARGSUSED */
 489 static int
 490 fcsm_port_attach(opaque_t ulph, fc_ulp_port_info_t *pinfo,
 491     fc_attach_cmd_t cmd, uint32_t s_id)
 492 {
 493         int     instance;
 494         int     rval = FC_FAILURE;
 495 
 496         instance = ddi_get_instance(pinfo->port_dip);
 497 
 498         /*
 499          * Set the attaching flag, so that fcsm_detach will fail, if
 500          * port attach is in progress.
 501          */
 502         mutex_enter(&fcsm_global_mutex);
 503         if (fcsm_detached) {
 504                 mutex_exit(&fcsm_global_mutex);
 505 
 506                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 507                     "port_attach: end. detach in progress. failing attach "
 508                     "instance 0x%x", instance));
 509                 return (((cmd == FC_CMD_POWER_UP) || (cmd == FC_CMD_RESUME)) ?
 510                     FC_FAILURE_SILENT : FC_FAILURE);
 511         }
 512 
 513         fcsm_num_attaching++;
 514         mutex_exit(&fcsm_global_mutex);
 515 
 516         switch (cmd) {
 517         case FC_CMD_ATTACH:
 518                 if (fcsm_handle_port_attach(pinfo, s_id, instance)
 519                     != DDI_SUCCESS) {
 520                         ASSERT(ddi_get_soft_state(fcsm_state,
 521                             instance) == NULL);
 522                         break;
 523                 }
 524                 rval = FC_SUCCESS;
 525                 break;
 526 
 527         case FC_CMD_RESUME:
 528         case FC_CMD_POWER_UP: {
 529                 fcsm_t  *fcsm;
 530                 char fcsm_pathname[MAXPATHLEN];
 531 
 532                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 533                     "port_attach: cmd 0x%x instance 0x%x", cmd, instance));
 534 
 535                 /* Get the soft state structure */
 536                 if ((fcsm = ddi_get_soft_state(fcsm_state, instance)) == NULL) {
 537                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
 538                             "port_attach: instance 0x%x, cmd 0x%x "
 539                             "get softstate failed", instance, cmd));
 540                         break;
 541                 }
 542 
 543                 ASSERT(fcsm->sm_instance == instance);
 544 
 545                 /* If this instance is not attached, then return failure */
 546                 mutex_enter(&fcsm->sm_mutex);
 547                 if ((fcsm->sm_flags & FCSM_ATTACHED) == 0) {
 548                         mutex_exit(&fcsm->sm_mutex);
 549                         fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
 550                             "port_detach: port is not attached");
 551                         break;
 552                 }
 553                 mutex_exit(&fcsm->sm_mutex);
 554 
 555                 if (fcsm_handle_port_resume(ulph, pinfo, cmd, s_id, fcsm) !=
 556                     DDI_SUCCESS) {
 557                         break;
 558                 }
 559 
 560                 (void) ddi_pathname(fcsm->sm_port_info.port_dip, fcsm_pathname);
 561                 fcsm_display(CE_NOTE, SM_LOG, fcsm, NULL,
 562                     "attached to path %s", fcsm_pathname);
 563                 rval = FC_SUCCESS;
 564                 break;
 565         }
 566 
 567         default:
 568                 FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, NULL, NULL,
 569                     "port_attach: unknown cmd 0x%x for port 0x%x",
 570                     cmd, instance));
 571                 break;
 572         }
 573 
 574         mutex_enter(&fcsm_global_mutex);
 575         fcsm_num_attaching--;
 576         mutex_exit(&fcsm_global_mutex);
 577         return (rval);
 578 }
 579 
 580 
 581 static int
 582 fcsm_handle_port_attach(fc_ulp_port_info_t *pinfo, uint32_t s_id, int instance)
 583 {
 584         fcsm_t          *fcsm;
 585         kthread_t       *thread;
 586         char            name[32];
 587         char fcsm_pathname[MAXPATHLEN];
 588 
 589         /* Allocate a soft state structure for the port */
 590         if (ddi_soft_state_zalloc(fcsm_state, instance) != DDI_SUCCESS) {
 591                 fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 592                     "port_attach: instance 0x%x, soft state alloc failed",
 593                     instance);
 594                 return (DDI_FAILURE);
 595         }
 596 
 597         if ((fcsm = ddi_get_soft_state(fcsm_state, instance)) == NULL) {
 598                 fcsm_display(CE_WARN, SM_LOG, NULL, NULL,
 599                     "port_attach: instance 0x%x, get soft state failed",
 600                     instance);
 601                 ddi_soft_state_free(fcsm_state, instance);
 602                 return (DDI_FAILURE);
 603         }
 604 
 605 
 606         /* Initialize the mutex */
 607         mutex_init(&fcsm->sm_mutex, NULL, MUTEX_DRIVER, NULL);
 608         cv_init(&fcsm->sm_job_cv, NULL, CV_DRIVER, NULL);
 609 
 610         mutex_enter(&fcsm->sm_mutex);
 611         fcsm->sm_flags               |= FCSM_ATTACHING;
 612         fcsm->sm_sid         = s_id;
 613         fcsm->sm_instance    = instance;
 614         fcsm->sm_port_state  = pinfo->port_state;
 615 
 616         /*
 617          * Make a copy of the port_information structure, since fctl
 618          * uses a temporary structure.
 619          */
 620         fcsm->sm_port_info   = *pinfo;       /* Structure copy !!! */
 621         mutex_exit(&fcsm->sm_mutex);
 622 
 623 
 624         (void) sprintf(name, "fcsm%d_cmd_cache", fcsm->sm_instance);
 625         fcsm->sm_cmd_cache = kmem_cache_create(name,
 626             sizeof (fcsm_cmd_t) + pinfo->port_fca_pkt_size, 8,
 627             fcsm_cmd_cache_constructor, fcsm_cmd_cache_destructor,
 628             NULL, (void *)fcsm, NULL, 0);
 629         if (fcsm->sm_cmd_cache == NULL) {
 630                 fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
 631                     "port_attach: pkt cache create failed");
 632                 cv_destroy(&fcsm->sm_job_cv);
 633                 mutex_destroy(&fcsm->sm_mutex);
 634                 ddi_soft_state_free(fcsm_state, instance);
 635                 return (DDI_FAILURE);
 636         }
 637 
 638         thread = thread_create((caddr_t)NULL, 0, fcsm_job_thread,
 639             (caddr_t)fcsm, 0, &p0, TS_RUN, v.v_maxsyspri-2);
 640         if (thread == NULL) {
 641                 fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
 642                     "port_attach: job thread create failed");
 643                 kmem_cache_destroy(fcsm->sm_cmd_cache);
 644                 cv_destroy(&fcsm->sm_job_cv);
 645                 mutex_destroy(&fcsm->sm_mutex);
 646                 ddi_soft_state_free(fcsm_state, instance);
 647                 return (DDI_FAILURE);
 648         }
 649 
 650         fcsm->sm_thread = thread;
 651 
 652         /* Add this structure to fcsm global linked list */
 653         mutex_enter(&fcsm_global_mutex);
 654         if (fcsm_port_head == NULL) {
 655                 fcsm_port_head = fcsm;
 656         } else {
 657                 fcsm->sm_next = fcsm_port_head;
 658                 fcsm_port_head = fcsm;
 659         }
 660         mutex_exit(&fcsm_global_mutex);
 661 
 662         mutex_enter(&fcsm->sm_mutex);
 663         fcsm->sm_flags &= ~FCSM_ATTACHING;
 664         fcsm->sm_flags |= FCSM_ATTACHED;
 665         fcsm->sm_port_top = pinfo->port_flags;
 666         fcsm->sm_port_state = pinfo->port_state;
 667         if (pinfo->port_acc_attr == NULL) {
 668                 /*
 669                  * The corresponding FCA doesn't support DMA at all
 670                  */
 671                 fcsm->sm_flags |= FCSM_USING_NODMA_FCA;
 672         }
 673         mutex_exit(&fcsm->sm_mutex);
 674 
 675         (void) ddi_pathname(fcsm->sm_port_info.port_dip, fcsm_pathname);
 676         fcsm_display(CE_NOTE, SM_LOG, fcsm, NULL,
 677             "attached to path %s", fcsm_pathname);
 678 
 679         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
 680             "port_attach: state <%s>(0x%x) topology <%s>(0x%x)",
 681             fcsm_port_state_to_str(FC_PORT_STATE_MASK(pinfo->port_state)),
 682             pinfo->port_state,
 683             fcsm_topology_to_str(pinfo->port_flags), pinfo->port_flags));
 684 
 685         return (DDI_SUCCESS);
 686 }
 687 
 688 static int
 689 fcsm_handle_port_resume(opaque_t ulph, fc_ulp_port_info_t *pinfo,
 690     fc_attach_cmd_t cmd, uint32_t s_id, fcsm_t *fcsm)
 691 {
 692         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
 693             "port_resume: cmd 0x%x", cmd));
 694 
 695         mutex_enter(&fcsm->sm_mutex);
 696 
 697         switch (cmd) {
 698         case FC_CMD_RESUME:
 699                 ASSERT(!(fcsm->sm_flags & FCSM_POWER_DOWN));
 700                 fcsm->sm_flags &= ~FCSM_SUSPENDED;
 701                 break;
 702 
 703         case FC_CMD_POWER_UP:
 704                 /* If port is suspended, then no need to resume */
 705                 fcsm->sm_flags &= ~FCSM_POWER_DOWN;
 706                 if (fcsm->sm_flags & FCSM_SUSPENDED) {
 707                         mutex_exit(&fcsm->sm_mutex);
 708                         return (DDI_SUCCESS);
 709                 }
 710                 break;
 711         default:
 712                 mutex_exit(&fcsm->sm_mutex);
 713                 return (DDI_FAILURE);
 714         }
 715 
 716         fcsm->sm_sid = s_id;
 717 
 718         /*
 719          * Make a copy of the new port_information structure
 720          */
 721         fcsm->sm_port_info   = *pinfo;       /* Structure copy !!! */
 722         mutex_exit(&fcsm->sm_mutex);
 723 
 724         fcsm_resume_port(fcsm);
 725 
 726         /*
 727          * Invoke state change processing.
 728          * This will ensure that
 729          *    - offline timer is started if new port state changed to offline.
 730          *    - MGMT_SERVER_LOGIN flag is reset.
 731          *    - Port topology is updated.
 732          */
 733         fcsm_statec_cb(ulph, (opaque_t)pinfo->port_handle, pinfo->port_state,
 734             pinfo->port_flags, NULL, 0, s_id);
 735 
 736         return (DDI_SUCCESS);
 737 }
 738 
 739 
 740 /* ARGSUSED */
 741 static int
 742 fcsm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 743 {
 744         int     rval = DDI_SUCCESS;
 745 
 746         switch (cmd) {
 747         case DDI_DETACH: {
 748                 fcsm_t  *fcsm;
 749 
 750                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 751                     "detach: start. cmd <DETACH>", cmd));
 752 
 753                 mutex_enter(&fcsm_global_mutex);
 754 
 755                 /*
 756                  * If port attach/detach in progress, then wait for 5 seconds
 757                  * for them to complete.
 758                  */
 759                 if (fcsm_num_attaching || fcsm_num_detaching) {
 760                         int count;
 761 
 762                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
 763                             "detach: wait for port attach/detach to complete"));
 764 
 765                         count = 0;
 766                         while ((count++ <= 30) &&
 767                             (fcsm_num_attaching || fcsm_num_detaching)) {
 768                                 mutex_exit(&fcsm_global_mutex);
 769                                 delay(drv_usectohz(1000000));
 770                                 mutex_enter(&fcsm_global_mutex);
 771                         }
 772 
 773                         /* Port attach/detach still in prog, so fail detach */
 774                         if (fcsm_num_attaching || fcsm_num_detaching) {
 775                                 mutex_exit(&fcsm_global_mutex);
 776                                 FCSM_DEBUG(SMDL_ERR, (CE_WARN, SM_LOG, NULL,
 777                                     NULL, "detach: Failing detach. port "
 778                                     "attach/detach in progress"));
 779                                 rval = DDI_FAILURE;
 780                                 break;
 781                         }
 782                 }
 783 
 784                 if (fcsm_port_head == NULL) {
 785                         /* Not much do, Succeed to detach. */
 786                         ddi_remove_minor_node(fcsm_dip, NULL);
 787                         fcsm_dip = NULL;
 788                         fcsm_detached = 0;
 789                         mutex_exit(&fcsm_global_mutex);
 790                         break;
 791                 }
 792 
 793                 /*
 794                  * Check to see, if any ports are active.
 795                  * If not, then set the DETACHING flag to indicate
 796                  * that they are being detached.
 797                  */
 798                 fcsm = fcsm_port_head;
 799                 while (fcsm != NULL) {
 800 
 801                         mutex_enter(&fcsm->sm_mutex);
 802                         if (!(fcsm->sm_flags & FCSM_ATTACHED) ||
 803                             fcsm->sm_ncmds || fcsm->sm_cb_count) {
 804                                 /* port is busy. We can't detach */
 805                                 mutex_exit(&fcsm->sm_mutex);
 806                                 break;
 807                         }
 808 
 809                         fcsm->sm_flags |= FCSM_DETACHING;
 810                         mutex_exit(&fcsm->sm_mutex);
 811 
 812                         fcsm = fcsm->sm_next;
 813                 }
 814 
 815                 /*
 816                  * If all ports could not be marked for detaching,
 817                  * then clear the flags and fail the detach.
 818                  * Also if a port attach is currently in progress
 819                  * then fail the detach.
 820                  */
 821                 if (fcsm != NULL || fcsm_num_attaching || fcsm_num_detaching) {
 822                         /*
 823                          * Some ports were busy, so can't detach.
 824                          * Clear the DETACHING flag and return failure
 825                          */
 826                         fcsm = fcsm_port_head;
 827                         while (fcsm != NULL) {
 828                                 mutex_enter(&fcsm->sm_mutex);
 829                                 if (fcsm->sm_flags & FCSM_DETACHING) {
 830                                         fcsm->sm_flags &= ~FCSM_DETACHING;
 831                                 }
 832                                 mutex_exit(&fcsm->sm_mutex);
 833 
 834                                 fcsm = fcsm->sm_next;
 835                         }
 836                         mutex_exit(&fcsm_global_mutex);
 837                         return (DDI_FAILURE);
 838                 } else {
 839                         fcsm_detached = 1;
 840                         /*
 841                          * Mark all the detaching ports as detached, as we
 842                          * will be detaching them
 843                          */
 844                         fcsm = fcsm_port_head;
 845                         while (fcsm != NULL) {
 846                                 mutex_enter(&fcsm->sm_mutex);
 847                                 fcsm->sm_flags &= ~FCSM_DETACHING;
 848                                 fcsm->sm_flags |= FCSM_DETACHED;
 849                                 mutex_exit(&fcsm->sm_mutex);
 850 
 851                                 fcsm = fcsm->sm_next;
 852                         }
 853                 }
 854                 mutex_exit(&fcsm_global_mutex);
 855 
 856 
 857                 /*
 858                  * Go ahead and detach the ports
 859                  */
 860                 mutex_enter(&fcsm_global_mutex);
 861                 while (fcsm_port_head != NULL) {
 862                         fcsm = fcsm_port_head;
 863                         mutex_exit(&fcsm_global_mutex);
 864 
 865                         /*
 866                          * Call fcsm_cleanup_port(). This cleansup and
 867                          * removes the fcsm structure from global linked list
 868                          */
 869                         fcsm_cleanup_port(fcsm);
 870 
 871                         /*
 872                          * Soft state cleanup done.
 873                          * Remember that fcsm struct doesn't exist anymore.
 874                          */
 875 
 876                         mutex_enter(&fcsm_global_mutex);
 877                 }
 878 
 879                 ddi_remove_minor_node(fcsm_dip, NULL);
 880                 fcsm_dip = NULL;
 881                 mutex_exit(&fcsm_global_mutex);
 882                 break;
 883         }
 884 
 885         case DDI_SUSPEND:
 886                 rval = DDI_SUCCESS;
 887                 break;
 888 
 889         default:
 890                 FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, NULL, NULL,
 891                     "detach: unknown cmd 0x%x", cmd));
 892                 rval = DDI_FAILURE;
 893                 break;
 894         }
 895 
 896         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
 897             "detach: end. cmd 0x%x, rval 0x%x", cmd, rval));
 898 
 899         return (rval);
 900 }
 901 
 902 
 903 /* ARGSUSED */
 904 static void
 905 fcsm_force_port_detach_all(void)
 906 {
 907         fcsm_t  *fcsm;
 908 
 909         fcsm = fcsm_port_head;
 910 
 911         while (fcsm) {
 912                 fcsm_cleanup_port(fcsm);
 913                 /*
 914                  * fcsm_cleanup_port will remove the current fcsm structure
 915                  * from the list, which will cause fcsm_port_head to point
 916                  * to what would have been the next structure on the list.
 917                  */
 918                 fcsm = fcsm_port_head;
 919         }
 920 }
 921 
 922 
 923 /* ARGSUSED */
 924 static int
 925 fcsm_port_detach(opaque_t ulph, fc_ulp_port_info_t *pinfo, fc_detach_cmd_t cmd)
 926 {
 927         int     instance;
 928         int     rval = FC_FAILURE;
 929         fcsm_t  *fcsm;
 930 
 931         instance = ddi_get_instance(pinfo->port_dip);
 932 
 933         mutex_enter(&fcsm_global_mutex);
 934         if (fcsm_detached) {
 935                 mutex_exit(&fcsm_global_mutex);
 936 
 937                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
 938                     "port_detach: end. instance 0x%x, fcsm is detached",
 939                     instance));
 940                 return (FC_SUCCESS);
 941         }
 942         fcsm_num_detaching++;   /* Set the flag */
 943         mutex_exit(&fcsm_global_mutex);
 944 
 945         /* Get the soft state structure */
 946         if ((fcsm = ddi_get_soft_state(fcsm_state, instance)) == NULL) {
 947                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
 948                     "port_detach: instance 0x%x, cmd 0x%x get softstate failed",
 949                     instance, cmd));
 950                 mutex_enter(&fcsm_global_mutex);
 951                 fcsm_num_detaching--;
 952                 mutex_exit(&fcsm_global_mutex);
 953                 return (rval);
 954         }
 955 
 956         ASSERT(fcsm->sm_instance == instance);
 957 
 958         /* If this instance is not attached, then fail the detach */
 959         mutex_enter(&fcsm->sm_mutex);
 960         if ((fcsm->sm_flags & FCSM_ATTACHED) == 0) {
 961                 mutex_exit(&fcsm->sm_mutex);
 962                 fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
 963                     "port_detach: port is not attached");
 964                 mutex_enter(&fcsm_global_mutex);
 965                 fcsm_num_detaching--;
 966                 mutex_exit(&fcsm_global_mutex);
 967                 return (rval);
 968         }
 969         mutex_exit(&fcsm->sm_mutex);
 970 
 971         /*
 972          * If fcsm has been detached, then all instance has already been
 973          * detached or are being detached. So succeed this detach.
 974          */
 975 
 976         switch (cmd) {
 977         case FC_CMD_DETACH:
 978         case FC_CMD_SUSPEND:
 979         case FC_CMD_POWER_DOWN:
 980                 break;
 981 
 982         default:
 983                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
 984                     "port_detach: port unknown cmd 0x%x", cmd));
 985                 mutex_enter(&fcsm_global_mutex);
 986                 fcsm_num_detaching--;
 987                 mutex_exit(&fcsm_global_mutex);
 988                 return (rval);
 989         };
 990 
 991         if (fcsm_handle_port_detach(pinfo, fcsm, cmd) == DDI_SUCCESS) {
 992                 rval = FC_SUCCESS;
 993         }
 994 
 995         mutex_enter(&fcsm_global_mutex);
 996         fcsm_num_detaching--;
 997         mutex_exit(&fcsm_global_mutex);
 998 
 999         /* If it was a detach, then fcsm state structure no longer exists */
1000         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1001             "port_detach: end. cmd 0x%x rval 0x%x", cmd, rval));
1002         return (rval);
1003 }
1004 
1005 
1006 static int
1007 fcsm_handle_port_detach(fc_ulp_port_info_t *pinfo, fcsm_t *fcsm,
1008     fc_detach_cmd_t cmd)
1009 {
1010         uint32_t        flag;
1011         int             count;
1012 #ifdef DEBUG
1013         char            pathname[MAXPATHLEN];
1014 #endif /* DEBUG */
1015 
1016         /*
1017          * If port is already powered down OR suspended and there is nothing
1018          * else to do then just return.
1019          * Otherwise, set the flag, so that no more new activity will be
1020          * initiated on this port.
1021          */
1022         mutex_enter(&fcsm->sm_mutex);
1023 
1024         switch (cmd) {
1025         case FC_CMD_DETACH:
1026                 flag = FCSM_DETACHING;
1027                 break;
1028 
1029         case FC_CMD_SUSPEND:
1030         case FC_CMD_POWER_DOWN:
1031                 ((cmd == FC_CMD_SUSPEND) ? (flag = FCSM_SUSPENDED) :
1032                     (flag = FCSM_POWER_DOWN));
1033                 if (fcsm->sm_flags &
1034                     (FCSM_POWER_DOWN | FCSM_SUSPENDED)) {
1035                         fcsm->sm_flags |= flag;
1036                         mutex_exit(&fcsm->sm_mutex);
1037                         return (DDI_SUCCESS);
1038                 }
1039                 break;
1040 
1041         default:
1042                 mutex_exit(&fcsm->sm_mutex);
1043                 return (DDI_FAILURE);
1044         };
1045 
1046         fcsm->sm_flags |= flag;
1047 
1048         /*
1049          * If some commands are pending OR callback in progress, then
1050          * wait for some finite amount of time for their completion.
1051          * TODO: add more checks here to check for cmd timeout, offline
1052          * timeout and other (??) threads.
1053          */
1054         count = 0;
1055         while ((count++ <= 30) && (fcsm->sm_ncmds || fcsm->sm_cb_count)) {
1056                 mutex_exit(&fcsm->sm_mutex);
1057                 delay(drv_usectohz(1000000));
1058                 mutex_enter(&fcsm->sm_mutex);
1059         }
1060         if (fcsm->sm_ncmds || fcsm->sm_cb_count) {
1061                 fcsm->sm_flags &= ~flag;
1062                 mutex_exit(&fcsm->sm_mutex);
1063                 fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
1064                     "port_detach: Failing suspend, port is busy");
1065                 return (DDI_FAILURE);
1066         }
1067         if (flag == FCSM_DETACHING) {
1068                 fcsm->sm_flags &= ~FCSM_DETACHING;
1069                 fcsm->sm_flags |= FCSM_DETACHED;
1070         }
1071 
1072         mutex_exit(&fcsm->sm_mutex);
1073 
1074         FCSM_DEBUG(SMDL_INFO, (CE_CONT, SM_LOG, fcsm, NULL,
1075             "port_detach: cmd 0x%x pathname <%s>",
1076             cmd, ddi_pathname(pinfo->port_dip, pathname)));
1077 
1078         if (cmd == FC_CMD_DETACH) {
1079                 fcsm_cleanup_port(fcsm);
1080                 /*
1081                  * Soft state cleanup done.
1082                  * Always remember that fcsm struct doesn't exist anymore.
1083                  */
1084         } else {
1085                 fcsm_suspend_port(fcsm);
1086         }
1087 
1088         return (DDI_SUCCESS);
1089 }
1090 
1091 static void
1092 fcsm_suspend_port(fcsm_t *fcsm)
1093 {
1094         mutex_enter(&fcsm->sm_mutex);
1095 
1096         if (fcsm->sm_offline_tid != NULL) {
1097                 timeout_id_t    tid;
1098 
1099                 tid = fcsm->sm_offline_tid;
1100                 fcsm->sm_offline_tid = (timeout_id_t)NULL;
1101                 mutex_exit(&fcsm->sm_mutex);
1102                 (void) untimeout(tid);
1103                 mutex_enter(&fcsm->sm_mutex);
1104                 fcsm->sm_flags |= FCSM_RESTORE_OFFLINE_TIMEOUT;
1105         }
1106 
1107         if (fcsm->sm_retry_tid != NULL) {
1108                 timeout_id_t    tid;
1109 
1110                 tid = fcsm->sm_retry_tid;
1111                 fcsm->sm_retry_tid = (timeout_id_t)NULL;
1112                 mutex_exit(&fcsm->sm_mutex);
1113                 (void) untimeout(tid);
1114                 mutex_enter(&fcsm->sm_mutex);
1115                 fcsm->sm_flags |= FCSM_RESTORE_RETRY_TIMEOUT;
1116         }
1117 
1118         mutex_exit(&fcsm->sm_mutex);
1119 }
1120 
1121 static void
1122 fcsm_resume_port(fcsm_t *fcsm)
1123 {
1124         mutex_enter(&fcsm->sm_mutex);
1125 
1126         if (fcsm->sm_flags & FCSM_RESTORE_OFFLINE_TIMEOUT) {
1127                 fcsm->sm_flags &= ~FCSM_RESTORE_OFFLINE_TIMEOUT;
1128 
1129                 /*
1130                  * If port if offline, link is not marked down and offline
1131                  * timer is not already running, then restart offline timer.
1132                  */
1133                 if (!(fcsm->sm_flags & FCSM_LINK_DOWN) &&
1134                     fcsm->sm_offline_tid == NULL &&
1135                     (fcsm->sm_flags & FCSM_PORT_OFFLINE)) {
1136                         fcsm->sm_offline_tid = timeout(fcsm_offline_timeout,
1137                             (caddr_t)fcsm, fcsm_offline_ticks);
1138                 }
1139         }
1140 
1141         if (fcsm->sm_flags & FCSM_RESTORE_RETRY_TIMEOUT) {
1142                 fcsm->sm_flags &= ~FCSM_RESTORE_RETRY_TIMEOUT;
1143 
1144                 /*
1145                  * If retry queue is not suspended and some cmds are waiting
1146                  * to be retried, then restart the retry timer
1147                  */
1148                 if (fcsm->sm_retry_head && fcsm->sm_retry_tid == NULL) {
1149                         fcsm->sm_retry_tid = timeout(fcsm_retry_timeout,
1150                             (caddr_t)fcsm, fcsm_retry_ticks);
1151                 }
1152         }
1153         mutex_exit(&fcsm->sm_mutex);
1154 }
1155 
1156 static void
1157 fcsm_cleanup_port(fcsm_t *fcsm)
1158 {
1159         fcsm_t          *curr, *prev;
1160         int             status;
1161         fcsm_job_t      *job;
1162 
1163         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1164             "fcsm_cleanup_port: entered"));
1165 
1166         /*
1167          * Kill the job thread
1168          */
1169         job = fcsm_alloc_job(KM_SLEEP);
1170         ASSERT(job != NULL);
1171         fcsm_init_job(job, fcsm->sm_instance, FCSM_JOB_THREAD_SHUTDOWN,
1172             FCSM_JOBFLAG_SYNC, NULL, NULL, NULL, NULL);
1173 
1174         status = fcsm_process_job(job, 0);
1175         ASSERT(status == FC_SUCCESS);
1176 
1177         ASSERT(job->job_result == FC_SUCCESS);
1178         fcsm_dealloc_job(job);
1179 
1180         /*
1181          * We got here after ensuring the no commands are pending or active.
1182          * Therefore retry timeout thread should NOT be running.
1183          * Kill the offline timeout thread if currently running.
1184          */
1185         mutex_enter(&fcsm->sm_mutex);
1186 
1187         ASSERT(fcsm->sm_retry_tid == NULL);
1188 
1189         if (fcsm->sm_offline_tid != NULL) {
1190                 timeout_id_t    tid;
1191 
1192                 tid = fcsm->sm_offline_tid;
1193                 fcsm->sm_offline_tid = (timeout_id_t)NULL;
1194                 mutex_exit(&fcsm->sm_mutex);
1195                 (void) untimeout(tid);
1196         } else {
1197                 mutex_exit(&fcsm->sm_mutex);
1198         }
1199 
1200         /* Remove from the fcsm state structure from global linked list */
1201         mutex_enter(&fcsm_global_mutex);
1202         curr = fcsm_port_head;
1203         prev = NULL;
1204         while (curr != fcsm && curr != NULL) {
1205                 prev = curr;
1206                 curr = curr->sm_next;
1207         }
1208         ASSERT(curr != NULL);
1209 
1210         if (prev == NULL) {
1211                 fcsm_port_head = curr->sm_next;
1212         } else {
1213                 prev->sm_next = curr->sm_next;
1214         }
1215         mutex_exit(&fcsm_global_mutex);
1216 
1217         if (fcsm->sm_cmd_cache != NULL) {
1218                 kmem_cache_destroy(fcsm->sm_cmd_cache);
1219         }
1220         cv_destroy(&fcsm->sm_job_cv);
1221         mutex_destroy(&fcsm->sm_mutex);
1222 
1223         /* Free the fcsm state structure */
1224         ddi_soft_state_free(fcsm_state, fcsm->sm_instance);
1225 }
1226 
1227 
1228 /* ARGSUSED */
1229 static void
1230 fcsm_statec_cb(opaque_t ulph, opaque_t port_handle, uint32_t port_state,
1231     uint32_t port_top, fc_portmap_t *devlist, uint32_t dev_cnt,
1232     uint32_t port_sid)
1233 {
1234         fcsm_t          *fcsm;
1235         timeout_id_t    offline_tid, retry_tid;
1236 
1237         mutex_enter(&fcsm_global_mutex);
1238         if (fcsm_detached) {
1239                 mutex_exit(&fcsm_global_mutex);
1240                 return;
1241         }
1242 
1243         fcsm = ddi_get_soft_state(fcsm_state,
1244             fc_ulp_get_port_instance(port_handle));
1245         if (fcsm == NULL) {
1246                 mutex_exit(&fcsm_global_mutex);
1247                 FCSM_DEBUG(SMDL_TRACE, (CE_NOTE, SM_LOG, NULL, NULL,
1248                     "statec_cb: instance 0x%x not found",
1249                     fc_ulp_get_port_instance(port_handle)));
1250                 return;
1251         }
1252         mutex_enter(&fcsm->sm_mutex);
1253         ASSERT(fcsm->sm_instance == fc_ulp_get_port_instance(port_handle));
1254         if ((fcsm->sm_flags & FCSM_ATTACHED) == 0) {
1255                 mutex_exit(&fcsm->sm_mutex);
1256                 mutex_exit(&fcsm_global_mutex);
1257                 FCSM_DEBUG(SMDL_TRACE, (CE_NOTE, SM_LOG, fcsm, NULL,
1258                     "statec_cb: port not attached"));
1259                 return;
1260         }
1261 
1262         ASSERT(fcsm->sm_cb_count >= 0);
1263 
1264         fcsm->sm_cb_count++;
1265         mutex_exit(&fcsm->sm_mutex);
1266         mutex_exit(&fcsm_global_mutex);
1267 
1268         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1269             "statec_cb: state <%s>(0x%x) topology <%s>(0x%x) dev_cnt %d",
1270             fcsm_port_state_to_str(FC_PORT_STATE_MASK(port_state)), port_state,
1271             fcsm_topology_to_str(port_top), port_top, dev_cnt));
1272 
1273         fcsm_disp_devlist(fcsm, devlist, dev_cnt);
1274 
1275         mutex_enter(&fcsm->sm_mutex);
1276 
1277         /*
1278          * Reset the Mgmt server Login flag, so that login is performed again.
1279          */
1280         fcsm->sm_flags &= ~FCSM_MGMT_SERVER_LOGGED_IN;
1281 
1282         fcsm->sm_sid = port_sid;
1283         fcsm->sm_port_top = port_top;
1284         fcsm->sm_port_state = port_state;
1285 
1286         switch (port_state) {
1287         case FC_STATE_OFFLINE:
1288         case FC_STATE_RESET:
1289         case FC_STATE_RESET_REQUESTED:
1290                 fcsm->sm_flags |= FCSM_PORT_OFFLINE;
1291                 break;
1292 
1293         case FC_STATE_ONLINE:
1294         case FC_STATE_LOOP:
1295         case FC_STATE_LIP:
1296         case FC_STATE_LIP_LBIT_SET:
1297                 fcsm->sm_flags &= ~FCSM_PORT_OFFLINE;
1298                 fcsm->sm_flags &= ~FCSM_LINK_DOWN;
1299                 break;
1300 
1301         case FC_STATE_NAMESERVICE:
1302         case FC_STATE_DEVICE_CHANGE:
1303         case FC_STATE_TARGET_PORT_RESET:
1304         default:
1305                 /* Do nothing */
1306                 break;
1307         }
1308 
1309         offline_tid = retry_tid = NULL;
1310         if (fcsm->sm_flags & FCSM_PORT_OFFLINE) {
1311                 /*
1312                  * Port is offline.
1313                  * Suspend cmd processing and start offline timeout thread.
1314                  */
1315                 if (fcsm->sm_offline_tid == NULL) {
1316                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1317                             "statec_cb: schedule offline timeout thread"));
1318                         fcsm->sm_flags |= FCSM_CMD_RETRY_Q_SUSPENDED;
1319                         /* Stop the cmd retry thread */
1320                         retry_tid = fcsm->sm_retry_tid;
1321                         fcsm->sm_retry_tid = (timeout_id_t)NULL;
1322 
1323                         fcsm->sm_offline_tid = timeout(fcsm_offline_timeout,
1324                             (caddr_t)fcsm, fcsm_offline_ticks);
1325                 }
1326 
1327         } else {
1328                 /*
1329                  * Port is online.
1330                  * Cancel offline timeout thread and resume command processing.
1331                  */
1332                 if (fcsm->sm_offline_tid) {
1333                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1334                             "statec_cb: cancel offline timeout thread"));
1335                         offline_tid = fcsm->sm_offline_tid;
1336                         fcsm->sm_offline_tid = (timeout_id_t)NULL;
1337                 }
1338 
1339                 fcsm->sm_flags &= ~FCSM_CMD_RETRY_Q_SUSPENDED;
1340                 /* Start retry thread if needed */
1341                 if (fcsm->sm_retry_head && fcsm->sm_retry_tid == NULL) {
1342                         fcsm->sm_retry_tid = timeout(fcsm_retry_timeout,
1343                             (caddr_t)fcsm, fcsm_retry_ticks);
1344                 }
1345         }
1346 
1347         mutex_exit(&fcsm->sm_mutex);
1348 
1349         if (offline_tid != NULL) {
1350                 (void) untimeout(offline_tid);
1351         }
1352 
1353         if (retry_tid != NULL) {
1354                 (void) untimeout(retry_tid);
1355         }
1356 
1357         mutex_enter(&fcsm->sm_mutex);
1358         fcsm->sm_cb_count--;
1359         ASSERT(fcsm->sm_cb_count >= 0);
1360         mutex_exit(&fcsm->sm_mutex);
1361 }
1362 
1363 
1364 static void
1365 fcsm_offline_timeout(void *handle)
1366 {
1367         fcsm_t  *fcsm = (fcsm_t *)handle;
1368 
1369         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1370             "offline_timeout"));
1371 
1372         mutex_enter(&fcsm->sm_mutex);
1373         if (fcsm->sm_flags & FCSM_PORT_OFFLINE) {
1374                 fcsm->sm_flags |= FCSM_LINK_DOWN;
1375         }
1376         fcsm->sm_offline_tid = (timeout_id_t)NULL;
1377         fcsm->sm_flags &= ~FCSM_CMD_RETRY_Q_SUSPENDED;
1378 
1379         /* Start the retry thread if needed */
1380         if (fcsm->sm_retry_head && fcsm->sm_retry_tid == NULL) {
1381                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1382                     "offline_timeout: reschedule cmd retry thread"));
1383                 ASSERT(fcsm->sm_retry_tid == NULL);
1384                 fcsm->sm_retry_tid = timeout(fcsm_retry_timeout,
1385                     (caddr_t)fcsm, fcsm_retry_ticks);
1386         }
1387         mutex_exit(&fcsm->sm_mutex);
1388 }
1389 
1390 /* ARGSUSED */
1391 static int
1392 fcsm_els_cb(opaque_t ulph, opaque_t port_handle, fc_unsol_buf_t *buf,
1393     uint32_t claimed)
1394 {
1395         return (FC_UNCLAIMED);
1396 }
1397 
1398 
1399 /* ARGSUSED */
1400 static int
1401 fcsm_data_cb(opaque_t ulph, opaque_t port_handle, fc_unsol_buf_t *buf,
1402     uint32_t claimed)
1403 {
1404         return (FC_UNCLAIMED);
1405 }
1406 
1407 
1408 /* ARGSUSED */
1409 static int
1410 fcsm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
1411     int *rval_p)
1412 {
1413         int retval = 0;
1414 
1415         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "ioctl: start"));
1416 
1417         mutex_enter(&fcsm_global_mutex);
1418         if (!(fcsm_flag & FCSM_OPEN)) {
1419                 mutex_exit(&fcsm_global_mutex);
1420                 return (ENXIO);
1421         }
1422         mutex_exit(&fcsm_global_mutex);
1423 
1424         /* Allow only root to talk */
1425         if (drv_priv(credp)) {
1426                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1427                     "ioctl: end (disallowing underprivileged user)"));
1428                 return (EPERM);
1429         }
1430 
1431         switch (cmd) {
1432 
1433         case FCSMIO_CMD: {
1434                 fcio_t  fcio;
1435                 int     status;
1436 #ifdef  _MULTI_DATAMODEL
1437                 switch (ddi_model_convert_from(mode & FMODELS)) {
1438                 case DDI_MODEL_ILP32: {
1439                         struct fcio32 fcio32;
1440 
1441                         if (status = ddi_copyin((void *)arg, (void *)&fcio32,
1442                             sizeof (struct fcio32), mode)) {
1443                                 retval = EFAULT;
1444                                 break;
1445                         }
1446                         fcio.fcio_xfer = fcio32.fcio_xfer;
1447                         fcio.fcio_cmd = fcio32.fcio_cmd;
1448                         fcio.fcio_flags = fcio32.fcio_flags;
1449                         fcio.fcio_cmd_flags = fcio32.fcio_cmd_flags;
1450                         fcio.fcio_ilen = (size_t)fcio32.fcio_ilen;
1451                         fcio.fcio_ibuf = (caddr_t)(long)fcio32.fcio_ibuf;
1452                         fcio.fcio_olen = (size_t)fcio32.fcio_olen;
1453                         fcio.fcio_obuf = (caddr_t)(long)fcio32.fcio_obuf;
1454                         fcio.fcio_alen = (size_t)fcio32.fcio_alen;
1455                         fcio.fcio_abuf = (caddr_t)(long)fcio32.fcio_abuf;
1456                         fcio.fcio_errno = fcio32.fcio_errno;
1457                         break;
1458                 }
1459 
1460                 case DDI_MODEL_NONE:
1461                         if (status = ddi_copyin((void *)arg, (void *)&fcio,
1462                             sizeof (fcio_t), mode)) {
1463                                 retval = EFAULT;
1464                         }
1465                         break;
1466                 }
1467 #else   /* _MULTI_DATAMODEL */
1468                 if (status = ddi_copyin((void *)arg, (void *)&fcio,
1469                     sizeof (fcio_t), mode)) {
1470                         retval = EFAULT;
1471                         break;
1472                 }
1473 #endif  /* _MULTI_DATAMODEL */
1474                 if (!status) {
1475                         retval = fcsm_fciocmd(arg, mode, credp, &fcio);
1476                 }
1477                 break;
1478         }
1479 
1480         default:
1481                 retval = ENOTTY;
1482                 break;
1483         }
1484 
1485         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "ioctl: end"));
1486         return (retval);
1487 }
1488 
1489 /* ARGSUSED */
1490 static int
1491 fcsm_port_ioctl(opaque_t ulph, opaque_t port_handle, dev_t dev, int cmd,
1492     intptr_t arg, int mode, cred_t *credp, int *rval, uint32_t claimed)
1493 {
1494         return (FC_UNCLAIMED);
1495 }
1496 
1497 
1498 /* ARGSUSED */
1499 static int
1500 fcsm_fciocmd(intptr_t arg, int mode, cred_t *credp, fcio_t *fcio)
1501 {
1502         int  retval = 0;
1503 
1504         switch (fcio->fcio_cmd) {
1505         case  FCSMIO_CT_CMD: {
1506                 fcsm_t          *fcsm;
1507                 caddr_t         user_ibuf, user_obuf;
1508                 caddr_t         req_iu, rsp_iu, abuf;
1509                 int             status, instance, count;
1510 
1511                 if ((fcio->fcio_xfer != FCIO_XFER_RW) ||
1512                     (fcio->fcio_ilen == 0) || (fcio->fcio_ibuf == 0) ||
1513                     (fcio->fcio_olen == 0) || (fcio->fcio_obuf == 0) ||
1514                     (fcio->fcio_alen == 0) || (fcio->fcio_abuf == 0) ||
1515                     (fcio->fcio_flags != 0) || (fcio->fcio_cmd_flags != 0) ||
1516                     (fcio->fcio_ilen > FCSM_MAX_CT_SIZE) ||
1517                     (fcio->fcio_olen > FCSM_MAX_CT_SIZE) ||
1518                     (fcio->fcio_alen > MAXPATHLEN)) {
1519                         retval = EINVAL;
1520                         break;
1521                 }
1522 
1523                 /*
1524                  * Get the destination port for which this ioctl
1525                  * is targeted. The abuf will have the fp_minor
1526                  * number.
1527                  */
1528                 abuf = kmem_zalloc(fcio->fcio_alen, KM_SLEEP);
1529                 ASSERT(abuf != NULL);
1530                 if (ddi_copyin(fcio->fcio_abuf, abuf, fcio->fcio_alen, mode)) {
1531                         retval = EFAULT;
1532                         kmem_free(abuf, fcio->fcio_alen);
1533                         break;
1534                 }
1535 
1536                 instance = *((int *)abuf);
1537                 kmem_free(abuf, fcio->fcio_alen);
1538 
1539                 if (instance < 0) {
1540                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
1541                             "fciocmd: instance 0x%x, invalid instance",
1542                             instance));
1543                         retval = ENXIO;
1544                         break;
1545                 }
1546 
1547                 /*
1548                  * We confirmed that path corresponds to our port driver
1549                  * and a valid instance.
1550                  * If this port instance is not yet attached, then wait
1551                  * for a finite time for attach to complete
1552                  */
1553                 fcsm = ddi_get_soft_state(fcsm_state, instance);
1554                 count = 0;
1555                 while (count++ <= 30) {
1556                         if (fcsm != NULL) {
1557                                 mutex_enter(&fcsm->sm_mutex);
1558                                 if (fcsm->sm_flags & FCSM_ATTACHED) {
1559                                         mutex_exit(&fcsm->sm_mutex);
1560                                         break;
1561                                 }
1562                                 mutex_exit(&fcsm->sm_mutex);
1563                         }
1564                         if (count == 1) {
1565                                 FCSM_DEBUG(SMDL_TRACE,
1566                                     (CE_WARN, SM_LOG, NULL, NULL,
1567                                     "fciocmd: instance 0x%x, "
1568                                     "wait for port attach", instance));
1569                         }
1570                         delay(drv_usectohz(1000000));
1571                         fcsm = ddi_get_soft_state(fcsm_state, instance);
1572                 }
1573                 if (count > 30) {
1574                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, NULL, NULL,
1575                             "fciocmd: instance 0x%x, port not attached",
1576                             instance));
1577                         retval = ENXIO;
1578                         break;
1579                 }
1580 
1581                 req_iu = kmem_zalloc(fcio->fcio_ilen, KM_SLEEP);
1582                 rsp_iu = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);
1583                 ASSERT((req_iu != NULL) && (rsp_iu != NULL));
1584 
1585                 if (ddi_copyin(fcio->fcio_ibuf, req_iu,
1586                     fcio->fcio_ilen, mode)) {
1587                         retval = EFAULT;
1588                         kmem_free(req_iu, fcio->fcio_ilen);
1589                         kmem_free(rsp_iu, fcio->fcio_olen);
1590                         break;
1591                 }
1592 
1593                 user_ibuf = fcio->fcio_ibuf;
1594                 user_obuf = fcio->fcio_obuf;
1595                 fcio->fcio_ibuf = req_iu;
1596                 fcio->fcio_obuf = rsp_iu;
1597 
1598                 status = fcsm_ct_passthru(fcsm->sm_instance, fcio, KM_SLEEP,
1599                     FCSM_JOBFLAG_SYNC, NULL);
1600                 if (status != FC_SUCCESS) {
1601                         retval = EIO;
1602                 }
1603 
1604                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1605                     "fciocmd: cmd 0x%x completion status 0x%x",
1606                     fcio->fcio_cmd, status));
1607                 fcio->fcio_errno = status;
1608                 fcio->fcio_ibuf = user_ibuf;
1609                 fcio->fcio_obuf = user_obuf;
1610 
1611                 if (ddi_copyout(rsp_iu, fcio->fcio_obuf,
1612                     fcio->fcio_olen, mode)) {
1613                         retval = EFAULT;
1614                         kmem_free(req_iu, fcio->fcio_ilen);
1615                         kmem_free(rsp_iu, fcio->fcio_olen);
1616                         break;
1617                 }
1618 
1619                 kmem_free(req_iu, fcio->fcio_ilen);
1620                 kmem_free(rsp_iu, fcio->fcio_olen);
1621 
1622                 if (fcsm_fcio_copyout(fcio, arg, mode)) {
1623                         retval = EFAULT;
1624                 }
1625                 break;
1626         }
1627 
1628         case  FCSMIO_ADAPTER_LIST: {
1629                 fc_hba_list_t   *list;
1630                 int                     count;
1631 
1632                 if ((fcio->fcio_xfer != FCIO_XFER_RW) ||
1633                     (fcio->fcio_olen == 0) || (fcio->fcio_obuf == 0)) {
1634                         retval = EINVAL;
1635                         break;
1636                 }
1637 
1638                 list = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);
1639 
1640                 if (ddi_copyin(fcio->fcio_obuf, list, fcio->fcio_olen, mode)) {
1641                         retval = EFAULT;
1642                         break;
1643                 }
1644                 list->version = FC_HBA_LIST_VERSION;
1645 
1646                 if (fcio->fcio_olen < MAXPATHLEN * list->numAdapters) {
1647                         retval = EFAULT;
1648                         break;
1649                 }
1650 
1651                 count = fc_ulp_get_adapter_paths((char *)list->hbaPaths,
1652                     list->numAdapters);
1653                 if (count < 0) {
1654                         /* Did something go wrong? */
1655                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1656                             "Error fetching adapter list."));
1657                         retval = ENXIO;
1658                         kmem_free(list, fcio->fcio_olen);
1659                         break;
1660                 }
1661                 /* Sucess (or short buffer) */
1662                 list->numAdapters = count;
1663                 if (ddi_copyout(list, fcio->fcio_obuf,
1664                     fcio->fcio_olen, mode)) {
1665                         retval = EFAULT;
1666                 }
1667                 kmem_free(list, fcio->fcio_olen);
1668                 break;
1669         }
1670 
1671         default:
1672                 FCSM_DEBUG(SMDL_TRACE, (CE_NOTE, SM_LOG, NULL, NULL,
1673                     "fciocmd: unknown cmd <0x%x>", fcio->fcio_cmd));
1674                 retval = ENOTTY;
1675                 break;
1676         }
1677 
1678         return (retval);
1679 }
1680 
1681 static int
1682 fcsm_fcio_copyout(fcio_t *fcio, intptr_t arg, int mode)
1683 {
1684         int status;
1685 
1686 #ifdef  _MULTI_DATAMODEL
1687         switch (ddi_model_convert_from(mode & FMODELS)) {
1688         case DDI_MODEL_ILP32: {
1689                 struct fcio32 fcio32;
1690 
1691                 fcio32.fcio_xfer = fcio->fcio_xfer;
1692                 fcio32.fcio_cmd = fcio->fcio_cmd;
1693                 fcio32.fcio_flags = fcio->fcio_flags;
1694                 fcio32.fcio_cmd_flags = fcio->fcio_cmd_flags;
1695                 fcio32.fcio_ilen = fcio->fcio_ilen;
1696                 fcio32.fcio_ibuf = (caddr32_t)(long)fcio->fcio_ibuf;
1697                 fcio32.fcio_olen = fcio->fcio_olen;
1698                 fcio32.fcio_obuf = (caddr32_t)(long)fcio->fcio_obuf;
1699                 fcio32.fcio_alen = fcio->fcio_alen;
1700                 fcio32.fcio_abuf = (caddr32_t)(long)fcio->fcio_abuf;
1701                 fcio32.fcio_errno = fcio->fcio_errno;
1702 
1703                 status = ddi_copyout((void *)&fcio32, (void *)arg,
1704                     sizeof (struct fcio32), mode);
1705                 break;
1706         }
1707         case DDI_MODEL_NONE:
1708                 status = ddi_copyout((void *)fcio, (void *)arg,
1709                     sizeof (fcio_t), mode);
1710                 break;
1711         }
1712 #else   /* _MULTI_DATAMODEL */
1713         status = ddi_copyout((void *)fcio, (void *)arg, sizeof (fcio_t), mode);
1714 #endif  /* _MULTI_DATAMODEL */
1715 
1716         return (status);
1717 }
1718 
1719 
1720 /* ARGSUSED */
1721 static int
1722 fcsm_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1723 {
1724         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "open"));
1725 
1726         if (otyp != OTYP_CHR) {
1727                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1728                     "fcsm_open: failed. open type 0x%x for minor 0x%x is not "
1729                     "OTYP_CHR", otyp, getminor(*devp)));
1730                 return (EINVAL);
1731         }
1732 
1733         /*
1734          * Allow anybody to open (both root and non-root users).
1735          * Previlege level checks are made on the per ioctl basis.
1736          */
1737         mutex_enter(&fcsm_global_mutex);
1738         if (flags & FEXCL) {
1739                 if (fcsm_flag & FCSM_OPEN) {
1740                         mutex_exit(&fcsm_global_mutex);
1741                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1742                             "fcsm_open: exclusive open of 0x%x failed",
1743                             getminor(*devp)));
1744                         return (EBUSY);
1745                 } else {
1746                         ASSERT(fcsm_flag == FCSM_IDLE);
1747                         fcsm_flag |= FCSM_EXCL;
1748                 }
1749         } else {
1750                 if (fcsm_flag & FCSM_EXCL) {
1751                         mutex_exit(&fcsm_global_mutex);
1752                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1753                             "fcsm_open: failed. Device minor 0x%x is in "
1754                             "exclusive open mode", getminor(*devp)));
1755                         return (EBUSY);
1756                 }
1757 
1758         }
1759         fcsm_flag |= FCSM_OPEN;
1760         mutex_exit(&fcsm_global_mutex);
1761         return (0);
1762 }
1763 
1764 
1765 /* ARGSUSED */
1766 static int
1767 fcsm_close(dev_t dev, int flag, int otyp, cred_t *credp)
1768 {
1769         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL, "close"));
1770 
1771         if (otyp != OTYP_CHR) {
1772                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1773                     "fcsm_close: failed. close type 0x%x for minor 0x%x is not "
1774                     "OTYP_CHR", otyp, getminor(dev)));
1775                 return (EINVAL);
1776         }
1777 
1778         mutex_enter(&fcsm_global_mutex);
1779         if ((fcsm_flag & FCSM_OPEN) == 0) {
1780                 mutex_exit(&fcsm_global_mutex);
1781                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
1782                     "fcsm_close: failed. minor 0x%x is already closed",
1783                     getminor(dev)));
1784                 return (ENODEV);
1785         }
1786         fcsm_flag = FCSM_IDLE;
1787         mutex_exit(&fcsm_global_mutex);
1788         return (0);
1789 }
1790 
1791 
1792 /* ARGSUSED */
1793 static void
1794 fcsm_disp_devlist(fcsm_t *fcsm, fc_portmap_t *devlist, uint32_t dev_cnt)
1795 {
1796         fc_portmap_t    *map;
1797         uint32_t        i;
1798 
1799         if (dev_cnt == 0) {
1800                 return;
1801         }
1802 
1803         ASSERT(devlist != NULL);
1804         for (i = 0; i < dev_cnt; i++) {
1805                 map = &devlist[i];
1806                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
1807                     "list[%d]: ID 0x%x WWN %x:%x:%x:%x:%x:%x:%x:%x "
1808                     "state (0x%x) "
1809                     "type <%s>(0x%x) "
1810                     "flags (0x%x)",
1811                     i, map->map_did.port_id,
1812                     map->map_pwwn.raw_wwn[0], map->map_pwwn.raw_wwn[1],
1813                     map->map_pwwn.raw_wwn[2], map->map_pwwn.raw_wwn[3],
1814                     map->map_pwwn.raw_wwn[4], map->map_pwwn.raw_wwn[5],
1815                     map->map_pwwn.raw_wwn[6], map->map_pwwn.raw_wwn[7],
1816                     map->map_state,
1817                     fcsm_dev_type_to_str(map->map_type), map->map_type,
1818                     map->map_flags));
1819         }
1820 }
1821 
1822 /* ARGSUSED */
1823 static void
1824 fcsm_display(int level, int flags, fcsm_t *fcsm, fc_packet_t *pkt,
1825     const char *fmt, ...)
1826 {
1827         caddr_t buf;
1828         va_list ap;
1829 
1830         buf = kmem_zalloc(256, KM_NOSLEEP);
1831         if (buf == NULL) {
1832                 return;
1833         }
1834 
1835         if (fcsm) {
1836                 (void) sprintf(buf + strlen(buf), "fcsm(%d): ",
1837                     ddi_get_instance(fcsm->sm_port_info.port_dip));
1838         } else {
1839                 (void) sprintf(buf, "fcsm: ");
1840         }
1841 
1842         va_start(ap, fmt);
1843         (void) vsprintf(buf + strlen(buf), fmt, ap);
1844         va_end(ap);
1845 
1846         if (pkt) {
1847                 caddr_t state, reason, action, expln;
1848 
1849                 (void) fc_ulp_pkt_error(pkt, &state, &reason, &action, &expln);
1850 
1851                 (void) sprintf(buf + strlen(buf),
1852                     " state: %s(0x%x); reason: %s(0x%x)",
1853                     state, pkt->pkt_state, reason, pkt->pkt_reason);
1854         }
1855 
1856         switch (flags) {
1857         case SM_LOG:
1858                 cmn_err(level, "!%s", buf);
1859                 break;
1860 
1861         case SM_CONSOLE:
1862                 cmn_err(level, "^%s", buf);
1863                 break;
1864 
1865         default:
1866                 cmn_err(level, "%s", buf);
1867                 break;
1868         }
1869 
1870         kmem_free(buf, 256);
1871 }
1872 
1873 
1874 /*
1875  * Convert FC packet state to FC errno
1876  */
1877 int
1878 fcsm_pkt_state_to_rval(uchar_t state, uint32_t reason)
1879 {
1880         int count;
1881 
1882         if (state == FC_PKT_LOCAL_RJT && (reason == FC_REASON_NO_CONNECTION ||
1883             reason == FC_REASON_LOGIN_REQUIRED)) {
1884                 return (FC_LOGINREQ);
1885         } else if (state == FC_PKT_PORT_OFFLINE &&
1886             reason == FC_REASON_LOGIN_REQUIRED) {
1887                 return (FC_LOGINREQ);
1888         }
1889 
1890         for (count = 0; count < sizeof (fcsm_xlat_pkt_state) /
1891             sizeof (fcsm_xlat_pkt_state[0]); count++) {
1892                 if (fcsm_xlat_pkt_state[count].xlat_state == state) {
1893                         return (fcsm_xlat_pkt_state[count].xlat_rval);
1894                 }
1895         }
1896 
1897         return (FC_FAILURE);
1898 }
1899 
1900 
1901 /*
1902  * Convert port state state to descriptive string
1903  */
1904 caddr_t
1905 fcsm_port_state_to_str(uint32_t port_state)
1906 {
1907         int count;
1908 
1909         for (count = 0; count < sizeof (fcsm_xlat_port_state) /
1910             sizeof (fcsm_xlat_port_state[0]); count++) {
1911                 if (fcsm_xlat_port_state[count].xlat_pstate == port_state) {
1912                         return (fcsm_xlat_port_state[count].xlat_state_str);
1913                 }
1914         }
1915 
1916         return (NULL);
1917 }
1918 
1919 
1920 /*
1921  * Convert port topology state to descriptive string
1922  */
1923 caddr_t
1924 fcsm_topology_to_str(uint32_t topology)
1925 {
1926         int count;
1927 
1928         for (count = 0; count < sizeof (fcsm_xlat_topology) /
1929             sizeof (fcsm_xlat_topology[0]); count++) {
1930                 if (fcsm_xlat_topology[count].xlat_top == topology) {
1931                         return (fcsm_xlat_topology[count].xlat_top_str);
1932                 }
1933         }
1934 
1935         return (NULL);
1936 }
1937 
1938 
1939 /*
1940  * Convert port topology state to descriptive string
1941  */
1942 static caddr_t
1943 fcsm_dev_type_to_str(uint32_t type)
1944 {
1945         int count;
1946 
1947         for (count = 0; count < sizeof (fcsm_xlat_dev_type) /
1948             sizeof (fcsm_xlat_dev_type[0]); count++) {
1949                 if (fcsm_xlat_dev_type[count].xlat_type == type) {
1950                         return (fcsm_xlat_dev_type[count].xlat_str);
1951                 }
1952         }
1953 
1954         return (NULL);
1955 }
1956 
1957 static int
1958 fcsm_cmd_cache_constructor(void *buf, void *cdarg, int kmflags)
1959 {
1960         fcsm_cmd_t              *cmd = (fcsm_cmd_t *)buf;
1961         fcsm_t                  *fcsm = (fcsm_t *)cdarg;
1962         int                     (*callback)(caddr_t);
1963         fc_packet_t             *pkt;
1964         fc_ulp_port_info_t      *pinfo;
1965 
1966         ASSERT(fcsm != NULL && buf != NULL);
1967         callback = (kmflags == KM_SLEEP) ? DDI_DMA_SLEEP: DDI_DMA_DONTWAIT;
1968 
1969         cmd->cmd_fp_pkt              = &cmd->cmd_fc_packet;
1970         cmd->cmd_job         = NULL;
1971         cmd->cmd_fcsm                = fcsm;
1972         cmd->cmd_dma_flags   = 0;
1973 
1974         pkt = &cmd->cmd_fc_packet;
1975 
1976         pkt->pkt_ulp_rscn_infop = NULL;
1977         pkt->pkt_fca_private = (opaque_t)((caddr_t)cmd + sizeof (fcsm_cmd_t));
1978         pkt->pkt_ulp_private = (opaque_t)cmd;
1979 
1980         if (!(fcsm->sm_flags & FCSM_USING_NODMA_FCA)) {
1981                 pinfo = &fcsm->sm_port_info;
1982                 if (ddi_dma_alloc_handle(pinfo->port_dip,
1983                     pinfo->port_cmd_dma_attr,
1984                     callback, NULL, &pkt->pkt_cmd_dma) != DDI_SUCCESS) {
1985                         return (1);
1986                 }
1987 
1988                 if (ddi_dma_alloc_handle(pinfo->port_dip,
1989                     pinfo->port_resp_dma_attr,
1990                     callback, NULL, &pkt->pkt_resp_dma) != DDI_SUCCESS) {
1991                         ddi_dma_free_handle(&pkt->pkt_cmd_dma);
1992                         return (1);
1993                 }
1994         } else {
1995                 pkt->pkt_cmd_dma  = NULL;
1996                 pkt->pkt_cmd   = NULL;
1997                 pkt->pkt_resp_dma = NULL;
1998                 pkt->pkt_resp          = NULL;
1999         }
2000 
2001         pkt->pkt_cmd_acc = pkt->pkt_resp_acc = NULL;
2002         pkt->pkt_cmd_cookie_cnt = pkt->pkt_resp_cookie_cnt =
2003             pkt->pkt_data_cookie_cnt = 0;
2004         pkt->pkt_cmd_cookie = pkt->pkt_resp_cookie =
2005             pkt->pkt_data_cookie = NULL;
2006 
2007         return (0);
2008 }
2009 
2010 
2011 /* ARGSUSED */
2012 static void
2013 fcsm_cmd_cache_destructor(void *buf, void *cdarg)
2014 {
2015         fcsm_cmd_t      *cmd = (fcsm_cmd_t *)buf;
2016         fcsm_t          *fcsm = (fcsm_t *)cdarg;
2017         fc_packet_t     *pkt;
2018 
2019         ASSERT(fcsm == cmd->cmd_fcsm);
2020 
2021         pkt = cmd->cmd_fp_pkt;
2022 
2023         if (pkt->pkt_cmd_dma != NULL) {
2024                 ddi_dma_free_handle(&pkt->pkt_cmd_dma);
2025         }
2026 
2027         if (pkt->pkt_resp_dma != NULL) {
2028                 ddi_dma_free_handle(&pkt->pkt_resp_dma);
2029         }
2030 }
2031 
2032 
2033 static fcsm_cmd_t *
2034 fcsm_alloc_cmd(fcsm_t *fcsm, uint32_t cmd_len, uint32_t resp_len, int sleep)
2035 {
2036         fcsm_cmd_t      *cmd;
2037         fc_packet_t     *pkt;
2038         int             rval;
2039         ulong_t         real_len;
2040         int             (*callback)(caddr_t);
2041         ddi_dma_cookie_t        pkt_cookie;
2042         ddi_dma_cookie_t        *cp;
2043         uint32_t                cnt;
2044         fc_ulp_port_info_t      *pinfo;
2045 
2046         ASSERT(fcsm != NULL);
2047         pinfo = &fcsm->sm_port_info;
2048 
2049         callback = (sleep == KM_SLEEP) ? DDI_DMA_SLEEP: DDI_DMA_DONTWAIT;
2050 
2051         cmd = (fcsm_cmd_t *)kmem_cache_alloc(fcsm->sm_cmd_cache, sleep);
2052         if (cmd == NULL) {
2053                 FCSM_DEBUG(SMDL_ERR, (CE_WARN, SM_LOG, fcsm, NULL,
2054                     "alloc_cmd: kmem_cache_alloc failed"));
2055                 return (NULL);
2056         }
2057 
2058         cmd->cmd_retry_count = 0;
2059         cmd->cmd_max_retries = 0;
2060         cmd->cmd_retry_interval      = 0;
2061         cmd->cmd_transport   = NULL;
2062 
2063         ASSERT(cmd->cmd_dma_flags == 0);
2064         ASSERT(cmd->cmd_fp_pkt == &cmd->cmd_fc_packet);
2065         pkt = cmd->cmd_fp_pkt;
2066 
2067         /* Zero out the important fc_packet fields */
2068         pkt->pkt_pd          = NULL;
2069         pkt->pkt_datalen     = 0;
2070         pkt->pkt_data                = NULL;
2071         pkt->pkt_state               = 0;
2072         pkt->pkt_action              = 0;
2073         pkt->pkt_reason              = 0;
2074         pkt->pkt_expln               = 0;
2075 
2076         /*
2077          * Now that pkt_pd is initialized, we can call fc_ulp_init_packet
2078          */
2079 
2080         if (fc_ulp_init_packet((opaque_t)pinfo->port_handle, pkt, sleep)
2081             != FC_SUCCESS) {
2082                 kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2083                 return (NULL);
2084         }
2085 
2086         if ((cmd_len) && !(fcsm->sm_flags & FCSM_USING_NODMA_FCA)) {
2087                 ASSERT(pkt->pkt_cmd_dma != NULL);
2088 
2089                 rval = ddi_dma_mem_alloc(pkt->pkt_cmd_dma, cmd_len,
2090                     fcsm->sm_port_info.port_acc_attr, DDI_DMA_CONSISTENT,
2091                     callback, NULL, (caddr_t *)&pkt->pkt_cmd, &real_len,
2092                     &pkt->pkt_cmd_acc);
2093 
2094                 if (rval != DDI_SUCCESS) {
2095                         (void) fc_ulp_uninit_packet(
2096                             (opaque_t)pinfo->port_handle, pkt);
2097                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2098                         fcsm_free_cmd_dma(cmd);
2099                         return (NULL);
2100                 }
2101 
2102                 cmd->cmd_dma_flags |= FCSM_CF_CMD_VALID_DMA_MEM;
2103 
2104                 if (real_len < cmd_len) {
2105                         (void) fc_ulp_uninit_packet(
2106                             (opaque_t)pinfo->port_handle, pkt);
2107                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2108                         fcsm_free_cmd_dma(cmd);
2109                         return (NULL);
2110                 }
2111 
2112                 rval = ddi_dma_addr_bind_handle(pkt->pkt_cmd_dma, NULL,
2113                     pkt->pkt_cmd, real_len, DDI_DMA_WRITE | DDI_DMA_CONSISTENT,
2114                     callback, NULL, &pkt_cookie, &pkt->pkt_cmd_cookie_cnt);
2115 
2116                 if (rval != DDI_DMA_MAPPED) {
2117                         (void) fc_ulp_uninit_packet(
2118                             (opaque_t)pinfo->port_handle, pkt);
2119                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2120                         fcsm_free_cmd_dma(cmd);
2121                         return (NULL);
2122                 }
2123 
2124                 cmd->cmd_dma_flags |= FCSM_CF_CMD_VALID_DMA_BIND;
2125 
2126                 if (pkt->pkt_cmd_cookie_cnt >
2127                     pinfo->port_cmd_dma_attr->dma_attr_sgllen) {
2128                         (void) fc_ulp_uninit_packet(
2129                             (opaque_t)pinfo->port_handle, pkt);
2130                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2131                         fcsm_free_cmd_dma(cmd);
2132                         return (NULL);
2133                 }
2134 
2135                 ASSERT(pkt->pkt_cmd_cookie_cnt != 0);
2136 
2137                 cp = pkt->pkt_cmd_cookie = (ddi_dma_cookie_t *)kmem_alloc(
2138                     pkt->pkt_cmd_cookie_cnt * sizeof (pkt_cookie),
2139                     KM_NOSLEEP);
2140 
2141                 if (cp == NULL) {
2142                         (void) fc_ulp_uninit_packet(
2143                             (opaque_t)pinfo->port_handle, pkt);
2144                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2145                         fcsm_free_cmd_dma(cmd);
2146                         return (NULL);
2147                 }
2148 
2149                 *cp = pkt_cookie;
2150                 cp++;
2151                 for (cnt = 1; cnt < pkt->pkt_cmd_cookie_cnt; cnt++, cp++) {
2152                         ddi_dma_nextcookie(pkt->pkt_cmd_dma, &pkt_cookie);
2153                         *cp = pkt_cookie;
2154                 }
2155         } else if (cmd_len != 0) {
2156                 pkt->pkt_cmd = kmem_zalloc(cmd_len, KM_SLEEP);
2157         }
2158 
2159         if ((resp_len) && !(fcsm->sm_flags & FCSM_USING_NODMA_FCA)) {
2160                 ASSERT(pkt->pkt_resp_dma != NULL);
2161 
2162                 rval = ddi_dma_mem_alloc(pkt->pkt_resp_dma, resp_len,
2163                     fcsm->sm_port_info.port_acc_attr, DDI_DMA_CONSISTENT,
2164                     callback, NULL, (caddr_t *)&pkt->pkt_resp, &real_len,
2165                     &pkt->pkt_resp_acc);
2166 
2167                 if (rval != DDI_SUCCESS) {
2168                         (void) fc_ulp_uninit_packet(
2169                             (opaque_t)pinfo->port_handle, pkt);
2170                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2171                         fcsm_free_cmd_dma(cmd);
2172                         return (NULL);
2173                 }
2174 
2175                 cmd->cmd_dma_flags |= FCSM_CF_RESP_VALID_DMA_MEM;
2176 
2177                 if (real_len < resp_len) {
2178                         (void) fc_ulp_uninit_packet(
2179                             (opaque_t)pinfo->port_handle, pkt);
2180                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2181                         fcsm_free_cmd_dma(cmd);
2182                         return (NULL);
2183                 }
2184 
2185                 rval = ddi_dma_addr_bind_handle(pkt->pkt_resp_dma, NULL,
2186                     pkt->pkt_resp, real_len, DDI_DMA_READ | DDI_DMA_CONSISTENT,
2187                     callback, NULL, &pkt_cookie, &pkt->pkt_resp_cookie_cnt);
2188 
2189                 if (rval != DDI_DMA_MAPPED) {
2190                         (void) fc_ulp_uninit_packet(
2191                             (opaque_t)pinfo->port_handle, pkt);
2192                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2193                         fcsm_free_cmd_dma(cmd);
2194                         return (NULL);
2195                 }
2196 
2197                 cmd->cmd_dma_flags |= FCSM_CF_RESP_VALID_DMA_BIND;
2198 
2199                 if (pkt->pkt_resp_cookie_cnt >
2200                     pinfo->port_resp_dma_attr->dma_attr_sgllen) {
2201                         (void) fc_ulp_uninit_packet(
2202                             (opaque_t)pinfo->port_handle, pkt);
2203                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2204                         fcsm_free_cmd_dma(cmd);
2205                         return (NULL);
2206                 }
2207 
2208                 ASSERT(pkt->pkt_resp_cookie_cnt != 0);
2209 
2210                 cp = pkt->pkt_resp_cookie = (ddi_dma_cookie_t *)kmem_alloc(
2211                     pkt->pkt_resp_cookie_cnt * sizeof (pkt_cookie),
2212                     KM_NOSLEEP);
2213 
2214                 if (cp == NULL) {
2215                         (void) fc_ulp_uninit_packet(
2216                             (opaque_t)pinfo->port_handle, pkt);
2217                         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2218                         fcsm_free_cmd_dma(cmd);
2219                         return (NULL);
2220                 }
2221 
2222                 *cp = pkt_cookie;
2223                 cp++;
2224                 for (cnt = 1; cnt < pkt->pkt_resp_cookie_cnt; cnt++, cp++) {
2225                         ddi_dma_nextcookie(pkt->pkt_resp_dma, &pkt_cookie);
2226                         *cp = pkt_cookie;
2227                 }
2228         } else if (resp_len != 0) {
2229                 pkt->pkt_resp = kmem_zalloc(resp_len, KM_SLEEP);
2230         }
2231 
2232         pkt->pkt_cmdlen = cmd_len;
2233         pkt->pkt_rsplen = resp_len;
2234 
2235         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2236             "alloc_cmd: cmd 0x%p", (void *)cmd));
2237         return (cmd);
2238 }
2239 
2240 static void
2241 fcsm_free_cmd(fcsm_cmd_t *cmd)
2242 {
2243         fcsm_t          *fcsm;
2244 
2245         fcsm = cmd->cmd_fcsm;
2246         ASSERT(fcsm != NULL);
2247 
2248         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2249             "free_cmd: cmd 0x%p", (void *)cmd));
2250 
2251         fcsm_free_cmd_dma(cmd);
2252 
2253         (void) fc_ulp_uninit_packet((opaque_t)fcsm->sm_port_info.port_handle,
2254             cmd->cmd_fp_pkt);
2255         kmem_cache_free(fcsm->sm_cmd_cache, (void *)cmd);
2256 }
2257 
2258 static void
2259 fcsm_free_cmd_dma(fcsm_cmd_t *cmd)
2260 {
2261         fc_packet_t     *pkt;
2262 
2263         pkt = cmd->cmd_fp_pkt;
2264         ASSERT(pkt != NULL);
2265 
2266         if (cmd->cmd_fcsm->sm_flags & FCSM_USING_NODMA_FCA) {
2267                 if (pkt->pkt_cmd) {
2268                         kmem_free(pkt->pkt_cmd, pkt->pkt_cmdlen);
2269                         pkt->pkt_cmd = NULL;
2270                 }
2271 
2272                 if (pkt->pkt_resp) {
2273                         kmem_free(pkt->pkt_resp, pkt->pkt_rsplen);
2274                         pkt->pkt_resp = NULL;
2275                 }
2276         }
2277 
2278         pkt->pkt_cmdlen = 0;
2279         pkt->pkt_rsplen = 0;
2280         pkt->pkt_tran_type = 0;
2281         pkt->pkt_tran_flags = 0;
2282 
2283         if (pkt->pkt_cmd_cookie != NULL) {
2284                 kmem_free(pkt->pkt_cmd_cookie, pkt->pkt_cmd_cookie_cnt *
2285                     sizeof (ddi_dma_cookie_t));
2286                 pkt->pkt_cmd_cookie = NULL;
2287         }
2288 
2289         if (pkt->pkt_resp_cookie != NULL) {
2290                 kmem_free(pkt->pkt_resp_cookie, pkt->pkt_resp_cookie_cnt *
2291                     sizeof (ddi_dma_cookie_t));
2292                 pkt->pkt_resp_cookie = NULL;
2293         }
2294 
2295         if (cmd->cmd_dma_flags & FCSM_CF_CMD_VALID_DMA_BIND) {
2296                 (void) ddi_dma_unbind_handle(pkt->pkt_cmd_dma);
2297         }
2298 
2299         if (cmd->cmd_dma_flags & FCSM_CF_CMD_VALID_DMA_MEM) {
2300                 if (pkt->pkt_cmd_acc) {
2301                         ddi_dma_mem_free(&pkt->pkt_cmd_acc);
2302                 }
2303         }
2304 
2305         if (cmd->cmd_dma_flags & FCSM_CF_RESP_VALID_DMA_BIND) {
2306                 (void) ddi_dma_unbind_handle(pkt->pkt_resp_dma);
2307         }
2308 
2309         if (cmd->cmd_dma_flags & FCSM_CF_RESP_VALID_DMA_MEM) {
2310                 if (pkt->pkt_resp_acc) {
2311                         ddi_dma_mem_free(&pkt->pkt_resp_acc);
2312                 }
2313         }
2314 
2315         cmd->cmd_dma_flags = 0;
2316 }
2317 
2318 /* ARGSUSED */
2319 static int
2320 fcsm_job_cache_constructor(void *buf, void *cdarg, int kmflag)
2321 {
2322         fcsm_job_t *job = (fcsm_job_t *)buf;
2323 
2324         mutex_init(&job->job_mutex, NULL, MUTEX_DRIVER, NULL);
2325         sema_init(&job->job_sema, 0, NULL, SEMA_DEFAULT, NULL);
2326 
2327         return (0);
2328 }
2329 
2330 /* ARGSUSED */
2331 static void
2332 fcsm_job_cache_destructor(void *buf, void *cdarg)
2333 {
2334         fcsm_job_t *job = (fcsm_job_t *)buf;
2335 
2336         sema_destroy(&job->job_sema);
2337         mutex_destroy(&job->job_mutex);
2338 }
2339 
2340 
2341 static fcsm_job_t *
2342 fcsm_alloc_job(int sleep)
2343 {
2344         fcsm_job_t      *job;
2345 
2346         job = (fcsm_job_t *)kmem_cache_alloc(fcsm_job_cache, sleep);
2347         if (job != NULL) {
2348                 job->job_code                = FCSM_JOB_NONE;
2349                 job->job_flags               = 0;
2350                 job->job_port_instance       = -1;
2351                 job->job_result              = -1;
2352                 job->job_arg         = (opaque_t)0;
2353                 job->job_caller_priv = (opaque_t)0;
2354                 job->job_comp                = NULL;
2355                 job->job_comp_arg    = (opaque_t)0;
2356                 job->job_priv                = (void *)0;
2357                 job->job_priv_flags  = 0;
2358                 job->job_next                = 0;
2359         }
2360 
2361         return (job);
2362 }
2363 
2364 static void
2365 fcsm_dealloc_job(fcsm_job_t *job)
2366 {
2367         kmem_cache_free(fcsm_job_cache, (void *)job);
2368 }
2369 
2370 
2371 static void
2372 fcsm_init_job(fcsm_job_t *job, int instance, uint32_t command, uint32_t flags,
2373     opaque_t arg, opaque_t caller_priv,
2374     void (*comp)(opaque_t, fcsm_job_t *, int), opaque_t comp_arg)
2375 {
2376         ASSERT(job != NULL);
2377         job->job_port_instance       = instance;
2378         job->job_code                = command;
2379         job->job_flags               = flags;
2380         job->job_arg         = arg;
2381         job->job_caller_priv = caller_priv;
2382         job->job_comp                = comp;
2383         job->job_comp_arg    = comp_arg;
2384         job->job_retry_count = 0;
2385 }
2386 
2387 static int
2388 fcsm_process_job(fcsm_job_t *job, int priority_flag)
2389 {
2390         fcsm_t  *fcsm;
2391         int     sync;
2392 
2393         ASSERT(job != NULL);
2394         ASSERT(!MUTEX_HELD(&job->job_mutex));
2395 
2396         fcsm = ddi_get_soft_state(fcsm_state, job->job_port_instance);
2397 
2398         if (fcsm == NULL) {
2399                 FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, NULL, NULL,
2400                     "process_job: port instance 0x%x not found",
2401                     job->job_port_instance));
2402                 return (FC_BADDEV);
2403         }
2404 
2405         mutex_enter(&job->job_mutex);
2406         /* Both SYNC and ASYNC flags should not be set */
2407         ASSERT(((job->job_flags & (FCSM_JOBFLAG_SYNC | FCSM_JOBFLAG_ASYNC)) ==
2408             FCSM_JOBFLAG_SYNC) || ((job->job_flags &
2409             (FCSM_JOBFLAG_SYNC | FCSM_JOBFLAG_ASYNC)) == FCSM_JOBFLAG_ASYNC));
2410         /*
2411          * Check if job is a synchronous job. We might not be able to
2412          * check it reliably after enque_job(), if job is an ASYNC job.
2413          */
2414         sync = job->job_flags & FCSM_JOBFLAG_SYNC;
2415         mutex_exit(&job->job_mutex);
2416 
2417         /* Queue the job for processing by job thread */
2418         fcsm_enque_job(fcsm, job, priority_flag);
2419 
2420         /* Wait for job completion, if it is a synchronous job */
2421         if (sync) {
2422                 /*
2423                  * This is a Synchronous Job. So job structure is available.
2424                  * Caller is responsible for freeing it.
2425                  */
2426                 FCSM_DEBUG(SMDL_ERR, (CE_CONT, SM_LOG, fcsm, NULL,
2427                     "process_job: Waiting for sync job <%p> completion",
2428                     (void *)job));
2429                 sema_p(&job->job_sema);
2430         }
2431 
2432         return (FC_SUCCESS);
2433 }
2434 
2435 static void
2436 fcsm_enque_job(fcsm_t *fcsm, fcsm_job_t *job, int priority_flag)
2437 {
2438         ASSERT(!MUTEX_HELD(&fcsm->sm_mutex));
2439 
2440         mutex_enter(&fcsm->sm_mutex);
2441         /* Queue the job at the head or tail depending on the job priority */
2442         if (priority_flag) {
2443                 FCSM_DEBUG(SMDL_INFO, (CE_CONT, SM_LOG, fcsm, NULL,
2444                     "enque_job: job 0x%p is high priority", job));
2445                 /* Queue at the head */
2446                 if (fcsm->sm_job_tail == NULL) {
2447                         ASSERT(fcsm->sm_job_head == NULL);
2448                         fcsm->sm_job_head = fcsm->sm_job_tail = job;
2449                 } else {
2450                         ASSERT(fcsm->sm_job_head != NULL);
2451                         job->job_next = fcsm->sm_job_head;
2452                         fcsm->sm_job_head = job;
2453                 }
2454         } else {
2455                 FCSM_DEBUG(SMDL_INFO, (CE_CONT, SM_LOG, fcsm, NULL,
2456                     "enque_job: job 0x%p is normal", job));
2457                 /* Queue at the tail */
2458                 if (fcsm->sm_job_tail == NULL) {
2459                         ASSERT(fcsm->sm_job_head == NULL);
2460                         fcsm->sm_job_head = fcsm->sm_job_tail = job;
2461                 } else {
2462                         ASSERT(fcsm->sm_job_head != NULL);
2463                         fcsm->sm_job_tail->job_next = job;
2464                         fcsm->sm_job_tail = job;
2465                 }
2466                 job->job_next = NULL;
2467         }
2468 
2469         /* Signal the job thread to process the job */
2470         cv_signal(&fcsm->sm_job_cv);
2471         mutex_exit(&fcsm->sm_mutex);
2472 }
2473 
2474 static int
2475 fcsm_retry_job(fcsm_t *fcsm, fcsm_job_t *job)
2476 {
2477         /*
2478          * If it is a CT passthru job and status is login required, then
2479          * retry the job so that login can be performed again.
2480          * Ensure that this retry is performed a finite number of times,
2481          * so that a faulty fabric does not cause us to retry forever.
2482          */
2483 
2484         switch (job->job_code) {
2485         case FCSM_JOB_CT_PASSTHRU: {
2486                 uint32_t        jobflag;
2487                 fc_ct_header_t  *ct_header;
2488 
2489                 if (job->job_result != FC_LOGINREQ) {
2490                         break;
2491                 }
2492 
2493                 /*
2494                  * If it is a management server command
2495                  * then Reset the Management server login flag, so that login
2496                  * gets re-established.
2497                  * If it is a Name server command,
2498                  * then it is 'fp' responsibility to perform the login.
2499                  */
2500                 ASSERT(job->job_arg != NULL);
2501                 ct_header =
2502                     (fc_ct_header_t *)((fcio_t *)job->job_arg)->fcio_ibuf;
2503                 if (ct_header->ct_fcstype == FCSTYPE_MGMTSERVICE) {
2504                         mutex_enter(&fcsm->sm_mutex);
2505                         fcsm->sm_flags &= ~FCSM_MGMT_SERVER_LOGGED_IN;
2506                         mutex_exit(&fcsm->sm_mutex);
2507                 }
2508 
2509                 if (job->job_retry_count >= fcsm_max_job_retries) {
2510                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2511                             "retry_job: job 0x%p max retries (%d) reached",
2512                             (void *)job, job->job_retry_count));
2513                         break;
2514                 }
2515 
2516                 /*
2517                  * Login is required again. Retry the command, so that
2518                  * login will get performed again.
2519                  */
2520                 mutex_enter(&job->job_mutex);
2521                 job->job_retry_count++;
2522                 jobflag = job->job_flags;
2523                 mutex_exit(&job->job_mutex);
2524 
2525                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2526                     "retry_job: retry(%d) job 0x%p",
2527                     job->job_retry_count, (void *)job));
2528                 /*
2529                  * This job should get picked up before the
2530                  * other jobs sitting in the queue.
2531                  * Requeue the command at the head and then
2532                  * reset the SERIALIZE flag.
2533                  */
2534                 fcsm_enque_job(fcsm, job, 1);
2535                 if (jobflag & FCSM_JOBFLAG_SERIALIZE) {
2536                         mutex_enter(&fcsm->sm_mutex);
2537                         ASSERT(fcsm->sm_flags & FCSM_SERIALIZE_JOBTHREAD);
2538                         fcsm->sm_flags &= ~FCSM_SERIALIZE_JOBTHREAD;
2539 
2540                         /* Signal the job thread to process the job */
2541                         cv_signal(&fcsm->sm_job_cv);
2542                         mutex_exit(&fcsm->sm_mutex);
2543                 }
2544 
2545                 /* Command is queued for retrying */
2546                 return (0);
2547         }
2548 
2549         default:
2550                 break;
2551         }
2552         return (1);
2553 }
2554 
2555 static void
2556 fcsm_jobdone(fcsm_job_t *job)
2557 {
2558         fcsm_t  *fcsm;
2559 
2560         fcsm = ddi_get_soft_state(fcsm_state, job->job_port_instance);
2561         ASSERT(fcsm != NULL);
2562 
2563         if (job->job_result != FC_SUCCESS) {
2564                 if (fcsm_retry_job(fcsm, job) == 0) {
2565                         /* Job retried. so just return from here */
2566                         return;
2567                 }
2568         }
2569 
2570         if (job->job_comp) {
2571                 job->job_comp(job->job_comp_arg, job, job->job_result);
2572         }
2573 
2574         mutex_enter(&job->job_mutex);
2575         if (job->job_flags & FCSM_JOBFLAG_SERIALIZE) {
2576                 mutex_exit(&job->job_mutex);
2577                 mutex_enter(&fcsm->sm_mutex);
2578                 ASSERT(fcsm->sm_flags & FCSM_SERIALIZE_JOBTHREAD);
2579                 fcsm->sm_flags &= ~FCSM_SERIALIZE_JOBTHREAD;
2580 
2581                 /* Signal the job thread to process the job */
2582                 cv_signal(&fcsm->sm_job_cv);
2583                 mutex_exit(&fcsm->sm_mutex);
2584                 mutex_enter(&job->job_mutex);
2585         }
2586 
2587         if (job->job_flags & FCSM_JOBFLAG_SYNC) {
2588                 mutex_exit(&job->job_mutex);
2589                 sema_v(&job->job_sema);
2590         } else {
2591                 mutex_exit(&job->job_mutex);
2592                 /* Async job, free the job structure */
2593                 fcsm_dealloc_job(job);
2594         }
2595 }
2596 
2597 fcsm_job_t *
2598 fcsm_deque_job(fcsm_t *fcsm)
2599 {
2600         fcsm_job_t      *job;
2601 
2602         ASSERT(MUTEX_HELD(&fcsm->sm_mutex));
2603 
2604         if (fcsm->sm_job_head == NULL) {
2605                 ASSERT(fcsm->sm_job_tail == NULL);
2606                 job = NULL;
2607         } else {
2608                 ASSERT(fcsm->sm_job_tail != NULL);
2609                 job = fcsm->sm_job_head;
2610                 if (job->job_next == NULL) {
2611                         ASSERT(fcsm->sm_job_tail == job);
2612                         fcsm->sm_job_tail = NULL;
2613                 }
2614                 fcsm->sm_job_head = job->job_next;
2615                 job->job_next = NULL;
2616         }
2617 
2618         return (job);
2619 }
2620 
2621 
2622 /* Dedicated per port thread to process various commands */
2623 static void
2624 fcsm_job_thread(fcsm_t *fcsm)
2625 {
2626         fcsm_job_t      *job;
2627 
2628         ASSERT(fcsm != NULL);
2629 #ifndef __lock_lint
2630         CALLB_CPR_INIT(&fcsm->sm_cpr_info, &fcsm->sm_mutex,
2631             callb_generic_cpr, "fcsm_job_thread");
2632 #endif /* __lock_lint */
2633 
2634         for (;;) {
2635                 mutex_enter(&fcsm->sm_mutex);
2636 
2637                 while (fcsm->sm_job_head == NULL ||
2638                     fcsm->sm_flags & FCSM_SERIALIZE_JOBTHREAD) {
2639                         CALLB_CPR_SAFE_BEGIN(&fcsm->sm_cpr_info);
2640                         cv_wait(&fcsm->sm_job_cv, &fcsm->sm_mutex);
2641                         CALLB_CPR_SAFE_END(&fcsm->sm_cpr_info, &fcsm->sm_mutex);
2642                 }
2643 
2644                 job = fcsm_deque_job(fcsm);
2645 
2646                 mutex_exit(&fcsm->sm_mutex);
2647 
2648                 mutex_enter(&job->job_mutex);
2649                 if (job->job_flags & FCSM_JOBFLAG_SERIALIZE) {
2650                         mutex_exit(&job->job_mutex);
2651 
2652                         mutex_enter(&fcsm->sm_mutex);
2653                         ASSERT(!(fcsm->sm_flags & FCSM_SERIALIZE_JOBTHREAD));
2654                         fcsm->sm_flags |= FCSM_SERIALIZE_JOBTHREAD;
2655                         mutex_exit(&fcsm->sm_mutex);
2656                 } else {
2657                         mutex_exit(&job->job_mutex);
2658                 }
2659 
2660                 ASSERT(fcsm->sm_instance == job->job_port_instance);
2661 
2662                 switch (job->job_code) {
2663                 case FCSM_JOB_NONE:
2664                         fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
2665                             "job_thread: uninitialized job code");
2666                         job->job_result = FC_FAILURE;
2667                         fcsm_jobdone(job);
2668                         break;
2669 
2670                 case FCSM_JOB_THREAD_SHUTDOWN:
2671                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2672                             "job_thread: job code <JOB PORT SHUTDOWN>"));
2673 
2674                         /*
2675                          * There should not be any pending jobs, when this
2676                          * is being called.
2677                          */
2678                         mutex_enter(&fcsm->sm_mutex);
2679                         ASSERT(fcsm->sm_job_head == NULL);
2680                         ASSERT(fcsm->sm_job_tail == NULL);
2681                         ASSERT(fcsm->sm_retry_head == NULL);
2682                         ASSERT(fcsm->sm_retry_tail == NULL);
2683                         job->job_result = FC_SUCCESS;
2684 #ifndef __lock_lint
2685                         CALLB_CPR_EXIT(&fcsm->sm_cpr_info);
2686 #endif
2687                         /* CPR_EXIT has also dropped the fcsm->sm_mutex */
2688 
2689                         fcsm_jobdone(job);
2690                         thread_exit();
2691                         /* NOTREACHED */
2692                         break;
2693 
2694                 case FCSM_JOB_LOGIN_NAME_SERVER:
2695                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2696                             "job_thread: job code <LOGIN_NAME_SERVER>"));
2697                         job->job_result = FC_SUCCESS;
2698                         fcsm_jobdone(job);
2699                         break;
2700 
2701                 case FCSM_JOB_LOGIN_MGMT_SERVER:
2702                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2703                             "job_thread: job code <LOGIN_MGMT_SERVER>"));
2704                         fcsm_job_login_mgmt_server(job);
2705                         break;
2706 
2707                 case FCSM_JOB_CT_PASSTHRU:
2708                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2709                             "job_thread: job code <CT_PASSTHRU>"));
2710                         fcsm_job_ct_passthru(job);
2711                         break;
2712 
2713                 default:
2714                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2715                             "job_thread: job code <UNKNOWN>"));
2716                         job->job_result = FC_FAILURE;
2717                         fcsm_jobdone(job);
2718                         break;
2719                 }
2720         }
2721 
2722         /* NOTREACHED */
2723 }
2724 
2725 
2726 static void
2727 fcsm_ct_init(fcsm_t *fcsm, fcsm_cmd_t *cmd, fc_ct_aiu_t *req_iu, size_t req_len,
2728     void (*comp_func)())
2729 {
2730         fc_packet_t     *pkt;
2731 
2732         pkt = cmd->cmd_fp_pkt;
2733         ASSERT(pkt != NULL);
2734 
2735         ASSERT(req_iu->aiu_header.ct_fcstype == FCSTYPE_MGMTSERVICE ||
2736             (req_iu->aiu_header.ct_fcstype == FCSTYPE_DIRECTORY &&
2737             req_iu->aiu_header.ct_fcssubtype == FCSSUB_DS_NAME_SERVER));
2738 
2739 
2740         /* Set the pkt d_id properly */
2741         if (req_iu->aiu_header.ct_fcstype == FCSTYPE_MGMTSERVICE) {
2742                 pkt->pkt_cmd_fhdr.d_id       = FS_MANAGEMENT_SERVER;
2743         } else {
2744                 pkt->pkt_cmd_fhdr.d_id       = FS_NAME_SERVER;
2745         }
2746 
2747         pkt->pkt_cmd_fhdr.r_ctl      = R_CTL_UNSOL_CONTROL;
2748         pkt->pkt_cmd_fhdr.rsvd       = 0;
2749         pkt->pkt_cmd_fhdr.s_id       = fcsm->sm_sid;
2750         pkt->pkt_cmd_fhdr.type       = FC_TYPE_FC_SERVICES;
2751         pkt->pkt_cmd_fhdr.f_ctl      = F_CTL_SEQ_INITIATIVE |
2752             F_CTL_FIRST_SEQ | F_CTL_END_SEQ;
2753         pkt->pkt_cmd_fhdr.seq_id = 0;
2754         pkt->pkt_cmd_fhdr.df_ctl = 0;
2755         pkt->pkt_cmd_fhdr.seq_cnt = 0;
2756         pkt->pkt_cmd_fhdr.ox_id = 0xffff;
2757         pkt->pkt_cmd_fhdr.rx_id = 0xffff;
2758         pkt->pkt_cmd_fhdr.ro = 0;
2759 
2760         pkt->pkt_timeout     = FCSM_MS_TIMEOUT;
2761         pkt->pkt_comp                = comp_func;
2762 
2763         FCSM_REP_WR(pkt->pkt_cmd_acc, req_iu, pkt->pkt_cmd, req_len);
2764 
2765         cmd->cmd_transport = fc_ulp_transport;
2766 }
2767 
2768 static void
2769 fcsm_ct_intr(fcsm_cmd_t *cmd)
2770 {
2771         fc_packet_t     *pkt;
2772         fcsm_job_t      *job;
2773         fcio_t          *fcio;
2774         fcsm_t          *fcsm;
2775 
2776         pkt = cmd->cmd_fp_pkt;
2777         job = cmd->cmd_job;
2778         ASSERT(job != NULL);
2779 
2780         fcio = job->job_arg;
2781         ASSERT(fcio != NULL);
2782 
2783         if (pkt->pkt_state != FC_PKT_SUCCESS) {
2784                 FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, cmd->cmd_fcsm, pkt,
2785                     "ct_intr: CT command <0x%x> to did 0x%x failed",
2786                     ((fc_ct_aiu_t *)fcio->fcio_ibuf)->aiu_header.ct_cmdrsp,
2787                     pkt->pkt_cmd_fhdr.d_id));
2788         } else {
2789                 /* Get the CT response payload */
2790                 fcsm = cmd->cmd_fcsm;
2791                 FCSM_REP_RD(pkt->pkt_resp_acc, fcio->fcio_obuf,
2792                     pkt->pkt_resp, fcio->fcio_olen);
2793         }
2794 
2795         job->job_result =
2796             fcsm_pkt_state_to_rval(pkt->pkt_state, pkt->pkt_reason);
2797 
2798         fcsm_free_cmd(cmd);
2799 
2800         fcsm_jobdone(job);
2801 }
2802 
2803 
2804 static void
2805 fcsm_job_ct_passthru(fcsm_job_t *job)
2806 {
2807         fcsm_t          *fcsm;
2808         fcio_t          *fcio;
2809         fcsm_cmd_t      *cmd;
2810         int             status;
2811         fc_ct_header_t  *ct_header;
2812 
2813         ASSERT(job != NULL);
2814         ASSERT(job->job_port_instance != -1);
2815 
2816         job->job_result = FC_FAILURE;
2817         fcsm = ddi_get_soft_state(fcsm_state, job->job_port_instance);
2818         if (fcsm == NULL) {
2819                 fcsm_jobdone(job);
2820                 return;
2821         }
2822 
2823         /*
2824          * Process the CT Passthru job only if port is attached
2825          * to a FABRIC.
2826          */
2827         if (!FC_TOP_EXTERNAL(fcsm->sm_port_top)) {
2828                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2829                     "job_ct_passthru: end (non-fabric port)"));
2830                 job->job_result = FC_BADDEV;
2831                 fcsm_jobdone(job);
2832                 return;
2833         }
2834 
2835         fcio = job->job_arg;
2836         ASSERT(fcio != NULL);
2837 
2838         /*
2839          * If it is NOT a Management Seriver (MS) or Name Server (NS) command
2840          * then complete the command with failure.
2841          */
2842         ct_header = (fc_ct_header_t *)fcio->fcio_ibuf;
2843 
2844         /*
2845          * According to libHBAAPI spec, CT header from libHBAAPI would always
2846          * be big endian, so we must swap CT header before continue in little
2847          * endian platforms.
2848          */
2849         mutex_enter(&job->job_mutex);
2850         if (!(job->job_flags & FCSM_JOBFLAG_CTHEADER_BE)) {
2851                 job->job_flags |= FCSM_JOBFLAG_CTHEADER_BE;
2852                 *((uint32_t *)((uint32_t *)ct_header + 0)) =
2853                     BE_32(*((uint32_t *)((uint32_t *)ct_header + 0)));
2854                 *((uint32_t *)((uint32_t *)ct_header + 1)) =
2855                     BE_32(*((uint32_t *)((uint32_t *)ct_header + 1)));
2856                 *((uint32_t *)((uint32_t *)ct_header + 2)) =
2857                     BE_32(*((uint32_t *)((uint32_t *)ct_header + 2)));
2858                 *((uint32_t *)((uint32_t *)ct_header + 3)) =
2859                     BE_32(*((uint32_t *)((uint32_t *)ct_header + 3)));
2860         }
2861         mutex_exit(&job->job_mutex);
2862 
2863         if (ct_header->ct_fcstype == FCSTYPE_MGMTSERVICE) {
2864                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2865                     "job_ct_passthru: Management Server Cmd"));
2866         } else if (ct_header->ct_fcstype == FCSTYPE_DIRECTORY) {
2867                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2868                     "job_ct_passthru: Name Server Cmd"));
2869         } else {
2870                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2871                     "job_ct_passthru: Unsupported Destination "
2872                     "gs_type <0x%x> gs_subtype <0x%x>",
2873                     ct_header->ct_fcstype, ct_header->ct_fcssubtype));
2874         }
2875 
2876         if (ct_header->ct_fcstype != FCSTYPE_MGMTSERVICE &&
2877             (ct_header->ct_fcstype != FCSTYPE_DIRECTORY ||
2878             ct_header->ct_fcssubtype != FCSSUB_DS_NAME_SERVER)) {
2879                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2880                     "job_ct_passthru: end (Not a Name Server OR "
2881                     "Mgmt Server Cmd)"));
2882                 job->job_result = FC_BADCMD;
2883                 fcsm_jobdone(job);
2884                 return;
2885         }
2886 
2887         /*
2888          * If it is an MS command and we are not logged in to the management
2889          * server, then start the login and requeue the command.
2890          * If login to management server is in progress, then reque the
2891          * command to wait for login to complete.
2892          */
2893         mutex_enter(&fcsm->sm_mutex);
2894         if ((ct_header->ct_fcstype == FCSTYPE_MGMTSERVICE) &&
2895             !(fcsm->sm_flags & FCSM_MGMT_SERVER_LOGGED_IN)) {
2896                 mutex_exit(&fcsm->sm_mutex);
2897                 if (fcsm_login_and_process_job(fcsm, job) != FC_SUCCESS) {
2898                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2899                             "job_ct_passthru: perform login failed"));
2900                         job->job_result = FC_FAILURE;
2901                         fcsm_jobdone(job);
2902                 }
2903                 return;
2904         }
2905         mutex_exit(&fcsm->sm_mutex);
2906 
2907         /*
2908          * We are already logged in to the management server.
2909          * Issue the CT Passthru command
2910          */
2911         cmd = fcsm_alloc_cmd(fcsm, fcio->fcio_ilen, fcio->fcio_olen, KM_SLEEP);
2912         if (cmd == NULL) {
2913                 job->job_result = FC_NOMEM;
2914                 fcsm_jobdone(job);
2915                 return;
2916         }
2917 
2918         FCSM_INIT_CMD(cmd, job, FC_TRAN_INTR | FC_TRAN_CLASS3, FC_PKT_EXCHANGE,
2919             fcsm_max_cmd_retries, fcsm_ct_intr);
2920 
2921         fcsm_ct_init(fcsm, cmd, (fc_ct_aiu_t *)fcio->fcio_ibuf, fcio->fcio_ilen,
2922             fcsm_pkt_common_intr);
2923 
2924         if ((status = fcsm_issue_cmd(cmd)) != FC_SUCCESS) {
2925                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, cmd->cmd_fcsm, NULL,
2926                     "job_ct_passthru: issue CT Passthru failed, status 0x%x",
2927                     status));
2928                 job->job_result = status;
2929                 fcsm_free_cmd(cmd);
2930                 fcsm_jobdone(job);
2931                 return;
2932         }
2933 }
2934 
2935 static int
2936 fcsm_login_and_process_job(fcsm_t *fcsm, fcsm_job_t *orig_job)
2937 {
2938         fcsm_job_t      *login_job;
2939 #ifdef DEBUG
2940         int             status;
2941 #endif /* DEBUG */
2942 
2943         if (orig_job->job_code != FCSM_JOB_CT_PASSTHRU) {
2944                 return (FC_FAILURE);
2945         }
2946 
2947         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
2948             "login_and_process_job: start login."));
2949 
2950         mutex_enter(&fcsm->sm_mutex);
2951         if (fcsm->sm_flags & FCSM_MGMT_SERVER_LOGGED_IN) {
2952                 /*
2953                  * Directory server login completed just now, while the
2954                  * mutex was dropped. Just queue the command again for
2955                  * processing.
2956                  */
2957                 mutex_exit(&fcsm->sm_mutex);
2958                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2959                     "login_and_process_job: got job 0x%p. login just "
2960                     "completed", (void *)orig_job));
2961                 fcsm_enque_job(fcsm, orig_job, 0);
2962                 return (FC_SUCCESS);
2963         }
2964 
2965         if (fcsm->sm_flags & FCSM_MGMT_SERVER_LOGIN_IN_PROG) {
2966                 /*
2967                  * Ideally we shouldn't have come here, since login
2968                  * job has the serialize flag set.
2969                  * Anyway, put the command back on the queue.
2970                  */
2971                 mutex_exit(&fcsm->sm_mutex);
2972                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
2973                     "login_and_process_job: got job 0x%p while login to "
2974                     "management server in progress", (void *)orig_job));
2975                 fcsm_enque_job(fcsm, orig_job, 0);
2976                 return (FC_SUCCESS);
2977         }
2978 
2979         fcsm->sm_flags |= FCSM_MGMT_SERVER_LOGIN_IN_PROG;
2980         mutex_exit(&fcsm->sm_mutex);
2981 
2982         login_job = fcsm_alloc_job(KM_SLEEP);
2983         ASSERT(login_job != NULL);
2984 
2985         /*
2986          * Mark the login job as SERIALIZE, so that all other jobs will
2987          * be processed after completing the login.
2988          * Save the original job (CT Passthru job) in the caller private
2989          * field in the job structure, so that CT command can be issued
2990          * after login has completed.
2991          */
2992         fcsm_init_job(login_job, fcsm->sm_instance, FCSM_JOB_LOGIN_MGMT_SERVER,
2993             FCSM_JOBFLAG_ASYNC | FCSM_JOBFLAG_SERIALIZE,
2994             (opaque_t)NULL, (opaque_t)orig_job, fcsm_login_ms_comp, NULL);
2995         orig_job->job_priv = (void *)login_job;
2996 
2997 #ifdef DEBUG
2998         status = fcsm_process_job(login_job, 1);
2999         ASSERT(status == FC_SUCCESS);
3000 #else /* DEBUG */
3001         (void) fcsm_process_job(login_job, 1);
3002 #endif /* DEBUG */
3003         return (FC_SUCCESS);
3004 }
3005 
3006 
3007 /* ARGSUSED */
3008 static void
3009 fcsm_login_ms_comp(opaque_t comp_arg, fcsm_job_t *login_job, int result)
3010 {
3011         fcsm_t          *fcsm;
3012         fcsm_job_t      *orig_job;
3013 
3014         ASSERT(login_job != NULL);
3015 
3016         orig_job = (fcsm_job_t *)login_job->job_caller_priv;
3017 
3018         ASSERT(orig_job != NULL);
3019         ASSERT(orig_job->job_priv == (void *)login_job);
3020         orig_job->job_priv = NULL;
3021 
3022         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
3023             "login_ms_comp: result 0x%x", login_job->job_result));
3024 
3025         /* Set the login flag in the per port fcsm structure */
3026         ASSERT(login_job->job_port_instance == orig_job->job_port_instance);
3027         fcsm = ddi_get_soft_state(fcsm_state, login_job->job_port_instance);
3028         ASSERT(fcsm != NULL);
3029 
3030         mutex_enter(&fcsm->sm_mutex);
3031         ASSERT((fcsm->sm_flags & FCSM_MGMT_SERVER_LOGGED_IN) == 0);
3032         ASSERT(fcsm->sm_flags & FCSM_MGMT_SERVER_LOGIN_IN_PROG);
3033         fcsm->sm_flags &= ~FCSM_MGMT_SERVER_LOGIN_IN_PROG;
3034         if (login_job->job_result != FC_SUCCESS) {
3035                 caddr_t msg;
3036 
3037                 /*
3038                  * Login failed. Complete the original job with FC_LOGINREQ
3039                  * status. Retry of that job will cause login to be
3040                  * retried.
3041                  */
3042                 mutex_exit(&fcsm->sm_mutex);
3043                 orig_job->job_result = FC_LOGINREQ;
3044                 fcsm_jobdone(orig_job);
3045 
3046                 (void) fc_ulp_error(login_job->job_result, &msg);
3047                 fcsm_display(CE_WARN, SM_LOG, fcsm, NULL,
3048                     "login_ms_comp: Management server login failed: <%s>", msg);
3049                 return;
3050         }
3051         fcsm->sm_flags |= FCSM_MGMT_SERVER_LOGGED_IN;
3052         mutex_exit(&fcsm->sm_mutex);
3053 
3054         /*
3055          * Queue the original job at the head of the queue for processing.
3056          */
3057         fcsm_enque_job(fcsm, orig_job, 1);
3058 }
3059 
3060 
3061 static void
3062 fcsm_els_init(fcsm_cmd_t *cmd, uint32_t d_id)
3063 {
3064         fc_packet_t     *pkt;
3065         fcsm_t          *fcsm;
3066 
3067         fcsm = cmd->cmd_fcsm;
3068         pkt = cmd->cmd_fp_pkt;
3069         ASSERT(fcsm != NULL && pkt != NULL);
3070 
3071         pkt->pkt_cmd_fhdr.r_ctl      = R_CTL_ELS_REQ;
3072         pkt->pkt_cmd_fhdr.d_id       = d_id;
3073         pkt->pkt_cmd_fhdr.rsvd       = 0;
3074         pkt->pkt_cmd_fhdr.s_id       = fcsm->sm_sid;
3075         pkt->pkt_cmd_fhdr.type       = FC_TYPE_EXTENDED_LS;
3076         pkt->pkt_cmd_fhdr.f_ctl      = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ;
3077         pkt->pkt_cmd_fhdr.seq_id = 0;
3078         pkt->pkt_cmd_fhdr.df_ctl = 0;
3079         pkt->pkt_cmd_fhdr.seq_cnt = 0;
3080         pkt->pkt_cmd_fhdr.ox_id = 0xffff;
3081         pkt->pkt_cmd_fhdr.rx_id = 0xffff;
3082         pkt->pkt_cmd_fhdr.ro = 0;
3083 
3084         pkt->pkt_timeout     = FCSM_ELS_TIMEOUT;
3085 }
3086 
3087 
3088 static int
3089 fcsm_xlogi_init(fcsm_t *fcsm, fcsm_cmd_t *cmd, uint32_t d_id,
3090     void (*comp_func)(), uchar_t ls_code)
3091 {
3092         ls_code_t       payload;
3093         fc_packet_t     *pkt;
3094         la_els_logi_t   *login_params;
3095         int             status;
3096 
3097         login_params = (la_els_logi_t *)
3098             kmem_zalloc(sizeof (la_els_logi_t), KM_SLEEP);
3099         if (login_params == NULL) {
3100                 return (FC_NOMEM);
3101         }
3102 
3103         status = fc_ulp_get_port_login_params(fcsm->sm_port_info.port_handle,
3104             login_params);
3105         if (status != FC_SUCCESS) {
3106                 kmem_free(login_params, sizeof (la_els_logi_t));
3107                 return (status);
3108         }
3109 
3110         pkt = cmd->cmd_fp_pkt;
3111 
3112         fcsm_els_init(cmd, d_id);
3113         pkt->pkt_comp = comp_func;
3114 
3115         payload.ls_code = ls_code;
3116         payload.mbz = 0;
3117 
3118         FCSM_REP_WR(pkt->pkt_cmd_acc, login_params,
3119             pkt->pkt_cmd, sizeof (la_els_logi_t));
3120         FCSM_REP_WR(pkt->pkt_cmd_acc, &payload,
3121             pkt->pkt_cmd, sizeof (payload));
3122 
3123         cmd->cmd_transport = fc_ulp_issue_els;
3124 
3125         kmem_free(login_params, sizeof (la_els_logi_t));
3126 
3127         return (FC_SUCCESS);
3128 }
3129 
3130 static void
3131 fcsm_xlogi_intr(fcsm_cmd_t *cmd)
3132 {
3133         fc_packet_t     *pkt;
3134         fcsm_job_t      *job;
3135         fcsm_t          *fcsm;
3136 
3137         pkt = cmd->cmd_fp_pkt;
3138         job = cmd->cmd_job;
3139         ASSERT(job != NULL);
3140 
3141         fcsm = cmd->cmd_fcsm;
3142         ASSERT(fcsm != NULL);
3143 
3144         if (pkt->pkt_state != FC_PKT_SUCCESS) {
3145                 fcsm_display(CE_WARN, SM_LOG, fcsm, pkt,
3146                     "xlogi_intr: login to DID 0x%x failed",
3147                     pkt->pkt_cmd_fhdr.d_id);
3148         } else {
3149                 /* Get the Login parameters of the Management Server */
3150                 FCSM_REP_RD(pkt->pkt_resp_acc, &fcsm->sm_ms_service_params,
3151                     pkt->pkt_resp, sizeof (la_els_logi_t));
3152         }
3153 
3154         job->job_result =
3155             fcsm_pkt_state_to_rval(pkt->pkt_state, pkt->pkt_reason);
3156 
3157         fcsm_free_cmd(cmd);
3158 
3159         fcsm_jobdone(job);
3160 }
3161 
3162 static void
3163 fcsm_job_login_mgmt_server(fcsm_job_t *job)
3164 {
3165         fcsm_t          *fcsm;
3166         fcsm_cmd_t      *cmd;
3167         int             status;
3168 
3169         ASSERT(job != NULL);
3170         ASSERT(job->job_port_instance != -1);
3171 
3172         fcsm = ddi_get_soft_state(fcsm_state, job->job_port_instance);
3173         if (fcsm == NULL) {
3174                 job->job_result = FC_NOMEM;
3175                 fcsm_jobdone(job);
3176                 return;
3177         }
3178 
3179         /*
3180          * Issue the  Login command to the management server.
3181          */
3182         cmd = fcsm_alloc_cmd(fcsm, sizeof (la_els_logi_t),
3183             sizeof (la_els_logi_t), KM_SLEEP);
3184         if (cmd == NULL) {
3185                 job->job_result = FC_NOMEM;
3186                 fcsm_jobdone(job);
3187                 return;
3188         }
3189 
3190         FCSM_INIT_CMD(cmd, job, FC_TRAN_INTR | FC_TRAN_CLASS3, FC_PKT_EXCHANGE,
3191             fcsm_max_cmd_retries, fcsm_xlogi_intr);
3192 
3193         status = fcsm_xlogi_init(fcsm, cmd, FS_MANAGEMENT_SERVER,
3194             fcsm_pkt_common_intr, LA_ELS_PLOGI);
3195 
3196         if (status != FC_SUCCESS) {
3197                 FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
3198                     "job_login_mgmt_server: plogi init failed. status 0x%x",
3199                     status));
3200                 job->job_result = status;
3201                 fcsm_free_cmd(cmd);
3202                 fcsm_jobdone(job);
3203                 return;
3204         }
3205 
3206         if ((status = fcsm_issue_cmd(cmd)) != FC_SUCCESS) {
3207                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, cmd->cmd_fcsm, NULL,
3208                     "job_ct_passthru: issue login cmd failed, status 0x%x",
3209                     status));
3210                 job->job_result = status;
3211                 fcsm_free_cmd(cmd);
3212                 fcsm_jobdone(job);
3213                 return;
3214         }
3215 }
3216 
3217 
3218 int
3219 fcsm_ct_passthru(int instance, fcio_t *fcio, int sleep, int job_flags,
3220     void (*func)(fcio_t *))
3221 {
3222         fcsm_job_t      *job;
3223         int             status;
3224 
3225         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
3226             "ct_passthru: instance 0x%x fcio 0x%p", instance, fcio));
3227         job = fcsm_alloc_job(sleep);
3228         ASSERT(sleep == KM_NOSLEEP || job != NULL);
3229 
3230         fcsm_init_job(job, instance, FCSM_JOB_CT_PASSTHRU, job_flags,
3231             (opaque_t)fcio, (opaque_t)func, fcsm_ct_passthru_comp, NULL);
3232         status = fcsm_process_job(job, 0);
3233         if (status != FC_SUCCESS) {
3234                 /* Job could not be issued. So free the job and return */
3235                 fcsm_dealloc_job(job);
3236                 return (status);
3237         }
3238 
3239         if (job_flags & FCSM_JOBFLAG_SYNC) {
3240                 status = job->job_result;
3241                 fcsm_dealloc_job(job);
3242         }
3243 
3244         return (status);
3245 }
3246 
3247 
3248 /* ARGSUSED */
3249 static void
3250 fcsm_ct_passthru_comp(opaque_t comp_arg, fcsm_job_t *job, int result)
3251 {
3252         ASSERT(job != NULL);
3253         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
3254             "ct_passthru_comp: result 0x%x port 0x%x",
3255             job->job_result, job->job_port_instance));
3256 }
3257 
3258 
3259 static void
3260 fcsm_pkt_common_intr(fc_packet_t *pkt)
3261 {
3262         fcsm_cmd_t      *cmd;
3263         int             jobstatus;
3264         fcsm_t          *fcsm;
3265 
3266         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, NULL, NULL,
3267             "pkt_common_intr"));
3268 
3269         cmd = (fcsm_cmd_t *)pkt->pkt_ulp_private;
3270         ASSERT(cmd != NULL);
3271 
3272         if (pkt->pkt_state == FC_PKT_SUCCESS) {
3273                 /* Command completed successfully. Just complete the command */
3274                 cmd->cmd_comp(cmd);
3275                 return;
3276         }
3277 
3278         fcsm = cmd->cmd_fcsm;
3279         ASSERT(fcsm != NULL);
3280 
3281         FCSM_DEBUG(SMDL_ERR, (CE_NOTE, SM_LOG, cmd->cmd_fcsm, pkt,
3282             "fc packet to DID 0x%x failed for pkt 0x%p",
3283             pkt->pkt_cmd_fhdr.d_id, pkt));
3284 
3285         mutex_enter(&fcsm->sm_mutex);
3286         if (fcsm->sm_flags & FCSM_LINK_DOWN) {
3287                 /*
3288                  * No need to retry the command. The link previously
3289                  * suffered an offline  timeout.
3290                  */
3291                 mutex_exit(&fcsm->sm_mutex);
3292                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, cmd->cmd_fcsm, NULL,
3293                     "pkt_common_intr: end. Link is down"));
3294                 cmd->cmd_comp(cmd);
3295                 return;
3296         }
3297         mutex_exit(&fcsm->sm_mutex);
3298 
3299         jobstatus = fcsm_pkt_state_to_rval(pkt->pkt_state, pkt->pkt_reason);
3300         if (jobstatus == FC_LOGINREQ) {
3301                 /*
3302                  * Login to the destination is required. No need to
3303                  * retry this cmd again.
3304                  */
3305                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, cmd->cmd_fcsm, NULL,
3306                     "pkt_common_intr: end. LOGIN required"));
3307                 cmd->cmd_comp(cmd);
3308                 return;
3309         }
3310 
3311         switch (pkt->pkt_state) {
3312         case FC_PKT_PORT_OFFLINE:
3313         case FC_PKT_LOCAL_RJT:
3314         case FC_PKT_TIMEOUT: {
3315                 uchar_t         pkt_state;
3316 
3317                 pkt_state = pkt->pkt_state;
3318                 cmd->cmd_retry_interval = fcsm_retry_interval;
3319                 if (fcsm_retry_cmd(cmd) != 0) {
3320                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG,
3321                             cmd->cmd_fcsm, NULL,
3322                             "common_intr: max retries(%d) reached, status 0x%x",
3323                             cmd->cmd_retry_count));
3324 
3325                         /*
3326                          * Restore the pkt_state to the actual failure status
3327                          * received at the time of pkt completion.
3328                          */
3329                         pkt->pkt_state = pkt_state;
3330                         pkt->pkt_reason = 0;
3331                         cmd->cmd_comp(cmd);
3332                 } else {
3333                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG,
3334                             cmd->cmd_fcsm, NULL,
3335                             "pkt_common_intr: retry(%d) on pkt state (0x%x)",
3336                             cmd->cmd_retry_count, pkt_state));
3337                 }
3338                 break;
3339         }
3340         default:
3341                 cmd->cmd_comp(cmd);
3342                 break;
3343         }
3344 }
3345 
3346 static int
3347 fcsm_issue_cmd(fcsm_cmd_t *cmd)
3348 {
3349         fc_packet_t     *pkt;
3350         fcsm_t          *fcsm;
3351         int             status;
3352 
3353         pkt = cmd->cmd_fp_pkt;
3354         fcsm = cmd->cmd_fcsm;
3355 
3356         /* Explicitly invalidate this field till fcsm decides to use it */
3357         pkt->pkt_ulp_rscn_infop = NULL;
3358 
3359         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3360             "issue_cmd: entry"));
3361 
3362         ASSERT(!MUTEX_HELD(&fcsm->sm_mutex));
3363         mutex_enter(&fcsm->sm_mutex);
3364         if (fcsm->sm_flags & FCSM_LINK_DOWN) {
3365                 /*
3366                  * Update the pkt_state/pkt_reason appropriately.
3367                  * Caller of this function can decide whether to call
3368                  * 'pkt->pkt_comp' or use the 'status' returned by this func.
3369                  */
3370                 mutex_exit(&fcsm->sm_mutex);
3371                 pkt->pkt_state = FC_PKT_PORT_OFFLINE;
3372                 pkt->pkt_reason = FC_REASON_OFFLINE;
3373                 return (FC_OFFLINE);
3374         }
3375         mutex_exit(&fcsm->sm_mutex);
3376 
3377         ASSERT(cmd->cmd_transport != NULL);
3378         status = cmd->cmd_transport(fcsm->sm_port_info.port_handle, pkt);
3379         if (status != FC_SUCCESS) {
3380                 switch (status) {
3381                 case FC_LOGINREQ:
3382                         /*
3383                          * No need to retry. Return the cause of failure.
3384                          * Also update the pkt_state/pkt_reason. Caller of
3385                          * this function can decide, whether to call
3386                          * 'pkt->pkt_comp' or use the 'status' code returned
3387                          * by this function.
3388                          */
3389                         pkt->pkt_state = FC_PKT_LOCAL_RJT;
3390                         pkt->pkt_reason = FC_REASON_LOGIN_REQUIRED;
3391                         break;
3392 
3393                 case FC_DEVICE_BUSY_NEW_RSCN:
3394                         /*
3395                          * There was a newer RSCN than what fcsm knows about.
3396                          * So, just retry again
3397                          */
3398                         cmd->cmd_retry_count = 0;
3399                         /*FALLTHROUGH*/
3400                 case FC_OFFLINE:
3401                 case FC_STATEC_BUSY:
3402                         /*
3403                          * TODO: set flag, so that command is retried after
3404                          * port is back online.
3405                          * FALL Through for now.
3406                          */
3407 
3408                 case FC_TRAN_BUSY:
3409                 case FC_NOMEM:
3410                 case FC_DEVICE_BUSY:
3411                         cmd->cmd_retry_interval = fcsm_retry_interval;
3412                         if (fcsm_retry_cmd(cmd) != 0) {
3413                                 FCSM_DEBUG(SMDL_TRACE,
3414                                     (CE_WARN, SM_LOG, fcsm, NULL,
3415                                     "issue_cmd: max retries (%d) reached",
3416                                     cmd->cmd_retry_count));
3417 
3418                                 /*
3419                                  * status variable is not changed here.
3420                                  * Return the cause of the original
3421                                  * cmd_transport failure.
3422                                  * Update the pkt_state/pkt_reason. Caller
3423                                  * of this function can decide whether to
3424                                  * call 'pkt->pkt_comp' or use the 'status'
3425                                  * code returned by this function.
3426                                  */
3427                                 pkt->pkt_state = FC_PKT_TRAN_BSY;
3428                                 pkt->pkt_reason = 0;
3429                         } else {
3430                                 FCSM_DEBUG(SMDL_TRACE,
3431                                     (CE_WARN, SM_LOG, fcsm, NULL,
3432                                     "issue_cmd: retry (%d) on fc status (0x%x)",
3433                                     cmd->cmd_retry_count, status));
3434 
3435                                 status = FC_SUCCESS;
3436                         }
3437                         break;
3438 
3439                 default:
3440                         FCSM_DEBUG(SMDL_TRACE, (CE_WARN, SM_LOG, fcsm, NULL,
3441                             "issue_cmd: failure status 0x%x", status));
3442 
3443                         pkt->pkt_state = FC_PKT_TRAN_ERROR;
3444                         pkt->pkt_reason = 0;
3445                         break;
3446 
3447 
3448                 }
3449         }
3450 
3451         return (status);
3452 }
3453 
3454 
3455 static int
3456 fcsm_retry_cmd(fcsm_cmd_t *cmd)
3457 {
3458         if (cmd->cmd_retry_count < cmd->cmd_max_retries) {
3459                 cmd->cmd_retry_count++;
3460                 fcsm_enque_cmd(cmd->cmd_fcsm, cmd);
3461                 return (0);
3462         }
3463 
3464         return (1);
3465 }
3466 
3467 static void
3468 fcsm_enque_cmd(fcsm_t *fcsm, fcsm_cmd_t *cmd)
3469 {
3470         ASSERT(!MUTEX_HELD(&fcsm->sm_mutex));
3471 
3472         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL, "enque_cmd"));
3473 
3474         cmd->cmd_next = NULL;
3475         mutex_enter(&fcsm->sm_mutex);
3476         if (fcsm->sm_retry_tail) {
3477                 ASSERT(fcsm->sm_retry_head != NULL);
3478                 fcsm->sm_retry_tail->cmd_next = cmd;
3479                 fcsm->sm_retry_tail = cmd;
3480         } else {
3481                 ASSERT(fcsm->sm_retry_tail == NULL);
3482                 fcsm->sm_retry_head = fcsm->sm_retry_tail = cmd;
3483 
3484                 /* Schedule retry thread, if not already running */
3485                 if (fcsm->sm_retry_tid == NULL) {
3486                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3487                             "enque_cmd: schedule retry thread"));
3488                         fcsm->sm_retry_tid = timeout(fcsm_retry_timeout,
3489                             (caddr_t)fcsm, fcsm_retry_ticks);
3490                 }
3491         }
3492         mutex_exit(&fcsm->sm_mutex);
3493 }
3494 
3495 
3496 static fcsm_cmd_t *
3497 fcsm_deque_cmd(fcsm_t *fcsm)
3498 {
3499         fcsm_cmd_t      *cmd;
3500 
3501         ASSERT(!MUTEX_HELD(&fcsm->sm_mutex));
3502 
3503         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL, "deque_cmd"));
3504 
3505         mutex_enter(&fcsm->sm_mutex);
3506         if (fcsm->sm_retry_head == NULL) {
3507                 ASSERT(fcsm->sm_retry_tail == NULL);
3508                 cmd = NULL;
3509         } else {
3510                 cmd = fcsm->sm_retry_head;
3511                 fcsm->sm_retry_head = cmd->cmd_next;
3512                 if (fcsm->sm_retry_head == NULL) {
3513                         fcsm->sm_retry_tail = NULL;
3514                 }
3515                 cmd->cmd_next = NULL;
3516         }
3517         mutex_exit(&fcsm->sm_mutex);
3518 
3519         return (cmd);
3520 }
3521 
3522 static void
3523 fcsm_retry_timeout(void *handle)
3524 {
3525         fcsm_t          *fcsm;
3526         fcsm_cmd_t      *curr_tail;
3527         fcsm_cmd_t      *cmd;
3528         int             done = 0;
3529         int             linkdown;
3530 
3531         fcsm = (fcsm_t *)handle;
3532 
3533         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL, "retry_timeout"));
3534 
3535         /*
3536          * If retry cmd queue is suspended, then go away.
3537          * This retry thread will be restarted, when cmd queue resumes.
3538          */
3539         mutex_enter(&fcsm->sm_mutex);
3540         if (fcsm->sm_flags & FCSM_CMD_RETRY_Q_SUSPENDED) {
3541                 /*
3542                  * Clear the retry_tid, to indicate that this routine is not
3543                  * currently being rescheduled.
3544                  */
3545                 fcsm->sm_retry_tid = (timeout_id_t)NULL;
3546                 mutex_exit(&fcsm->sm_mutex);
3547                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3548                     "retry_timeout: end. No processing. "
3549                     "Queue is currently suspended for this instance"));
3550                 return;
3551         }
3552 
3553         linkdown = (fcsm->sm_flags & FCSM_LINK_DOWN) ? 1 : 0;
3554 
3555         /*
3556          * Save the curr_tail, so that we only process the commands
3557          * which are in the queue at this time.
3558          */
3559         curr_tail = fcsm->sm_retry_tail;
3560         mutex_exit(&fcsm->sm_mutex);
3561 
3562         /*
3563          * Check for done flag before dequeing the command.
3564          * Dequeing before checking the done flag will cause a command
3565          * to be lost.
3566          */
3567         while ((!done) && ((cmd = fcsm_deque_cmd(fcsm)) != NULL)) {
3568 
3569                 if (cmd == curr_tail) {
3570                         done = 1;
3571                 }
3572 
3573                 cmd->cmd_retry_interval -= fcsm_retry_ticker;
3574 
3575                 if (linkdown) {
3576                         fc_packet_t *pkt;
3577 
3578                         /*
3579                          * No need to retry the command. The link has
3580                          * suffered an offline  timeout.
3581                          */
3582                         pkt = cmd->cmd_fp_pkt;
3583                         pkt->pkt_state = FC_PKT_PORT_OFFLINE;
3584                         pkt->pkt_reason = FC_REASON_OFFLINE;
3585                         pkt->pkt_comp(pkt);
3586                         continue;
3587                 }
3588 
3589                 if (cmd->cmd_retry_interval <= 0) {
3590                         /* Retry the command */
3591                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3592                             "retry_timeout: issue cmd 0x%p", (void *)cmd));
3593                         if (fcsm_issue_cmd(cmd) != FC_SUCCESS) {
3594                                 cmd->cmd_fp_pkt->pkt_comp(cmd->cmd_fp_pkt);
3595                         }
3596                 } else {
3597                         /*
3598                          * Put the command back on the queue. Retry time
3599                          * has not yet reached.
3600                          */
3601                         FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3602                             "retry_timeout: queue cmd 0x%p", (void *)cmd));
3603                         fcsm_enque_cmd(fcsm, cmd);
3604                 }
3605         }
3606 
3607         mutex_enter(&fcsm->sm_mutex);
3608         if (fcsm->sm_retry_head) {
3609                 /* Activate timer */
3610                 fcsm->sm_retry_tid = timeout(fcsm_retry_timeout,
3611                     (caddr_t)fcsm, fcsm_retry_ticks);
3612                 FCSM_DEBUG(SMDL_TRACE, (CE_CONT, SM_LOG, fcsm, NULL,
3613                     "retry_timeout: retry thread rescheduled"));
3614         } else {
3615                 /*
3616                  * Reset the tid variable. The first thread which queues the
3617                  * command, will restart the timer.
3618                  */
3619                 fcsm->sm_retry_tid = (timeout_id_t)NULL;
3620         }
3621         mutex_exit(&fcsm->sm_mutex);
3622 }