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