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 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved. 27 */ 28 /* 29 * Fibre channel Transport Library (fctl) 30 * 31 * Function naming conventions: 32 * Functions called from ULPs begin with fc_ulp_ 33 * Functions called from FCAs begin with fc_fca_ 34 * Internal functions begin with fctl_ 35 * 36 * Fibre channel packet layout: 37 * +---------------------+<--------+ 38 * | | | 39 * | ULP Packet private | | 40 * | | | 41 * +---------------------+ | 42 * | |---------+ 43 * | struct fc_packet |---------+ 44 * | | | 45 * +---------------------+<--------+ 46 * | | 47 * | FCA Packet private | 48 * | | 49 * +---------------------+ 50 * 51 * So you loved the ascii art ? It's strongly desirable to cache 52 * allocate the entire packet in one common place. So we define a set a 53 * of rules. In a contiguous block of memory, the top portion of the 54 * block points to ulp packet private area, next follows the fc_packet 55 * structure used extensively by all the consumers and what follows this 56 * is the FCA packet private. Note that given a packet structure, it is 57 * possible to get to the ULP and FCA Packet private fields using 58 * ulp_private and fca_private fields (which hold pointers) respectively. 59 * 60 * It should be noted with a grain of salt that ULP Packet private size 61 * varies between two different ULP types, So this poses a challenge to 62 * compute the correct size of the whole block on a per port basis. The 63 * transport layer doesn't have a problem in dealing with FCA packet 64 * private sizes as it is the sole manager of ports underneath. Since 65 * it's not a good idea to cache allocate different sizes of memory for 66 * different ULPs and have the ability to choose from one of these caches 67 * based on ULP type during every packet allocation, the transport some 68 * what wisely (?) hands off this job of cache allocation to the ULPs 69 * themselves. 70 * 71 * That means FCAs need to make their packet private size known to the 72 * transport to pass it up to the ULPs. This is done during 73 * fc_fca_attach(). And the transport passes this size up to ULPs during 74 * fc_ulp_port_attach() of each ULP. 75 * 76 * This leaves us with another possible question; How are packets 77 * allocated for ELS's started by the transport itself ? Well, the port 78 * driver during attach time, cache allocates on a per port basis to 79 * handle ELSs too. 80 */ 81 82 #include <sys/note.h> 83 #include <sys/types.h> 84 #include <sys/varargs.h> 85 #include <sys/param.h> 86 #include <sys/errno.h> 87 #include <sys/uio.h> 88 #include <sys/buf.h> 89 #include <sys/modctl.h> 90 #include <sys/open.h> 91 #include <sys/kmem.h> 92 #include <sys/poll.h> 93 #include <sys/conf.h> 94 #include <sys/cmn_err.h> 95 #include <sys/stat.h> 96 #include <sys/ddi.h> 97 #include <sys/sunddi.h> 98 #include <sys/promif.h> 99 #include <sys/byteorder.h> 100 #include <sys/fibre-channel/fc.h> 101 #include <sys/fibre-channel/impl/fc_ulpif.h> 102 #include <sys/fibre-channel/impl/fc_fcaif.h> 103 #include <sys/fibre-channel/impl/fctl_private.h> 104 #include <sys/fibre-channel/impl/fc_portif.h> 105 106 /* These are referenced by fp.c! */ 107 int did_table_size = D_ID_HASH_TABLE_SIZE; 108 int pwwn_table_size = PWWN_HASH_TABLE_SIZE; 109 110 static fc_ulp_module_t *fctl_ulp_modules; 111 static fc_fca_port_t *fctl_fca_portlist; 112 static fc_ulp_list_t *fctl_ulp_list; 113 114 static char fctl_greeting[] = 115 "fctl: %s ULP same type (0x%x) as existing module.\n"; 116 117 static char *fctl_undefined = "Undefined"; 118 119 /* 120 * This lock protects the fc_ulp_module_t linked list (i.e. mod_next field) 121 */ 122 123 static krwlock_t fctl_ulp_lock; 124 125 /* 126 * The fctl_mod_ports_lock protects the mod_ports element in the 127 * fc_ulp_ports_t structure 128 */ 129 130 static krwlock_t fctl_mod_ports_lock; 131 132 /* 133 * fctl_port_lock protects the linked list of local port structures 134 * (fctl_fca_portlist). When walking the list, this lock must be obtained 135 * prior to any local port locks. 136 */ 137 138 static kmutex_t fctl_port_lock; 139 static kmutex_t fctl_ulp_list_mutex; 140 141 static fctl_nwwn_list_t *fctl_nwwn_hash_table; 142 static kmutex_t fctl_nwwn_hash_mutex; 143 int fctl_nwwn_table_size = NWWN_HASH_TABLE_SIZE; 144 145 #if !defined(lint) 146 _NOTE(MUTEX_PROTECTS_DATA(fctl_nwwn_hash_mutex, fctl_nwwn_hash_table)) 147 _NOTE(MUTEX_PROTECTS_DATA(fctl_ulp_list_mutex, fctl_ulp_list)) 148 _NOTE(RWLOCK_PROTECTS_DATA(fctl_ulp_lock, ulp_module::mod_next)) 149 _NOTE(RWLOCK_PROTECTS_DATA(fctl_mod_ports_lock, ulp_module::mod_ports 150 ulp_ports::port_handle)) 151 _NOTE(DATA_READABLE_WITHOUT_LOCK(ulp_module::mod_info)) 152 _NOTE(MUTEX_PROTECTS_DATA(ulp_ports::port_mutex, ulp_ports::port_statec 153 ulp_ports::port_dstate)) 154 #endif /* lint */ 155 156 #define FCTL_VERSION "20090729-1.70" 157 #define FCTL_NAME_VERSION "SunFC Transport v" FCTL_VERSION 158 159 char *fctl_version = FCTL_NAME_VERSION; 160 161 extern struct mod_ops mod_miscops; 162 163 static struct modlmisc modlmisc = { 164 &mod_miscops, /* type of module */ 165 FCTL_NAME_VERSION /* Module name */ 166 }; 167 168 static struct modlinkage modlinkage = { 169 MODREV_1, (void *)&modlmisc, NULL 170 }; 171 172 static struct bus_ops fctl_fca_busops = { 173 BUSO_REV, 174 nullbusmap, /* bus_map */ 175 NULL, /* bus_get_intrspec */ 176 NULL, /* bus_add_intrspec */ 177 NULL, /* bus_remove_intrspec */ 178 i_ddi_map_fault, /* bus_map_fault */ 179 NULL, /* bus_dma_map */ 180 ddi_dma_allochdl, /* bus_dma_allochdl */ 181 ddi_dma_freehdl, /* bus_dma_freehdl */ 182 ddi_dma_bindhdl, /* bus_dma_bindhdl */ 183 ddi_dma_unbindhdl, /* bus_unbindhdl */ 184 ddi_dma_flush, /* bus_dma_flush */ 185 ddi_dma_win, /* bus_dma_win */ 186 ddi_dma_mctl, /* bus_dma_ctl */ 187 fctl_fca_bus_ctl, /* bus_ctl */ 188 ddi_bus_prop_op, /* bus_prop_op */ 189 NULL, /* bus_get_eventcookie */ 190 NULL, /* bus_add_eventcall */ 191 NULL, /* bus_remove_event */ 192 NULL, /* bus_post_event */ 193 NULL, /* bus_intr_ctl */ 194 NULL, /* bus_config */ 195 NULL, /* bus_unconfig */ 196 NULL, /* bus_fm_init */ 197 NULL, /* bus_fm_fini */ 198 NULL, /* bus_fm_access_enter */ 199 NULL, /* bus_fm_access_exit */ 200 NULL, /* bus_power */ 201 NULL 202 }; 203 204 struct kmem_cache *fctl_job_cache; 205 206 static fc_errmap_t fc_errlist [] = { 207 { FC_FAILURE, "Operation failed" }, 208 { FC_SUCCESS, "Operation success" }, 209 { FC_CAP_ERROR, "Capability error" }, 210 { FC_CAP_FOUND, "Capability found" }, 211 { FC_CAP_SETTABLE, "Capability settable" }, 212 { FC_UNBOUND, "Port not bound" }, 213 { FC_NOMEM, "No memory" }, 214 { FC_BADPACKET, "Bad packet" }, 215 { FC_OFFLINE, "Port offline" }, 216 { FC_OLDPORT, "Old Port" }, 217 { FC_NO_MAP, "No map available" }, 218 { FC_TRANSPORT_ERROR, "Transport error" }, 219 { FC_ELS_FREJECT, "ELS Frejected" }, 220 { FC_ELS_PREJECT, "ELS PRejected" }, 221 { FC_ELS_BAD, "Bad ELS request" }, 222 { FC_ELS_MALFORMED, "Malformed ELS request" }, 223 { FC_TOOMANY, "Too many commands" }, 224 { FC_UB_BADTOKEN, "Bad Unsolicited buffer token" }, 225 { FC_UB_ERROR, "Unsolicited buffer error" }, 226 { FC_UB_BUSY, "Unsolicited buffer busy" }, 227 { FC_BADULP, "Bad ULP" }, 228 { FC_BADTYPE, "Bad Type" }, 229 { FC_UNCLAIMED, "Not Claimed" }, 230 { FC_ULP_SAMEMODULE, "Same ULP Module" }, 231 { FC_ULP_SAMETYPE, "Same ULP Type" }, 232 { FC_ABORTED, "Command Aborted" }, 233 { FC_ABORT_FAILED, "Abort Failed" }, 234 { FC_BADEXCHANGE, "Bad Exchange" }, 235 { FC_BADWWN, "Bad World Wide Name" }, 236 { FC_BADDEV, "Bad Device" }, 237 { FC_BADCMD, "Bad Command" }, 238 { FC_BADOBJECT, "Bad Object" }, 239 { FC_BADPORT, "Bad Port" }, 240 { FC_NOTTHISPORT, "Not on this Port" }, 241 { FC_PREJECT, "Operation Prejected" }, 242 { FC_FREJECT, "Operation Frejected" }, 243 { FC_PBUSY, "Operation Pbusyed" }, 244 { FC_FBUSY, "Operation Fbusyed" }, 245 { FC_ALREADY, "Already done" }, 246 { FC_LOGINREQ, "PLOGI Required" }, 247 { FC_RESETFAIL, "Reset operation failed" }, 248 { FC_INVALID_REQUEST, "Invalid Request" }, 249 { FC_OUTOFBOUNDS, "Out of Bounds" }, 250 { FC_TRAN_BUSY, "Command transport Busy" }, 251 { FC_STATEC_BUSY, "State change Busy" }, 252 { FC_DEVICE_BUSY, "Port driver is working on this device" } 253 }; 254 255 fc_pkt_reason_t remote_stop_reasons [] = { 256 { FC_REASON_ABTS, "Abort Sequence" }, 257 { FC_REASON_ABTX, "Abort Exchange" }, 258 { FC_REASON_INVALID, NULL } 259 }; 260 261 fc_pkt_reason_t general_reasons [] = { 262 { FC_REASON_HW_ERROR, "Hardware Error" }, 263 { FC_REASON_SEQ_TIMEOUT, "Sequence Timeout" }, 264 { FC_REASON_ABORTED, "Aborted" }, 265 { FC_REASON_ABORT_FAILED, "Abort Failed" }, 266 { FC_REASON_NO_CONNECTION, "No Connection" }, 267 { FC_REASON_XCHG_DROPPED, "Exchange Dropped" }, 268 { FC_REASON_ILLEGAL_FRAME, "Illegal Frame" }, 269 { FC_REASON_ILLEGAL_LENGTH, "Illegal Length" }, 270 { FC_REASON_UNSUPPORTED, "Unsuported" }, 271 { FC_REASON_RX_BUF_TIMEOUT, "Receive Buffer Timeout" }, 272 { FC_REASON_FCAL_OPN_FAIL, "FC AL Open Failed" }, 273 { FC_REASON_OVERRUN, "Over run" }, 274 { FC_REASON_QFULL, "Queue Full" }, 275 { FC_REASON_ILLEGAL_REQ, "Illegal Request", }, 276 { FC_REASON_PKT_BUSY, "Busy" }, 277 { FC_REASON_OFFLINE, "Offline" }, 278 { FC_REASON_BAD_XID, "Bad Exchange Id" }, 279 { FC_REASON_XCHG_BSY, "Exchange Busy" }, 280 { FC_REASON_NOMEM, "No Memory" }, 281 { FC_REASON_BAD_SID, "Bad S_ID" }, 282 { FC_REASON_NO_SEQ_INIT, "No Sequence Initiative" }, 283 { FC_REASON_DIAG_BUSY, "Diagnostic Busy" }, 284 { FC_REASON_DMA_ERROR, "DMA Error" }, 285 { FC_REASON_CRC_ERROR, "CRC Error" }, 286 { FC_REASON_ABORT_TIMEOUT, "Abort Timeout" }, 287 { FC_REASON_FCA_UNIQUE, "FCA Unique" }, 288 { FC_REASON_INVALID, NULL } 289 }; 290 291 fc_pkt_reason_t rjt_reasons [] = { 292 { FC_REASON_INVALID_D_ID, "Invalid D_ID" }, 293 { FC_REASON_INVALID_S_ID, "Invalid S_ID" }, 294 { FC_REASON_TEMP_UNAVAILABLE, "Temporarily Unavailable" }, 295 { FC_REASON_PERM_UNAVAILABLE, "Permamnently Unavailable" }, 296 { FC_REASON_CLASS_NOT_SUPP, "Class Not Supported", }, 297 { FC_REASON_DELIMTER_USAGE_ERROR, 298 "Delimeter Usage Error" }, 299 { FC_REASON_TYPE_NOT_SUPP, "Type Not Supported" }, 300 { FC_REASON_INVALID_LINK_CTRL, "Invalid Link Control" }, 301 { FC_REASON_INVALID_R_CTL, "Invalid R_CTL" }, 302 { FC_REASON_INVALID_F_CTL, "Invalid F_CTL" }, 303 { FC_REASON_INVALID_OX_ID, "Invalid OX_ID" }, 304 { FC_REASON_INVALID_RX_ID, "Invalid RX_ID" }, 305 { FC_REASON_INVALID_SEQ_ID, "Invalid Sequence ID" }, 306 { FC_REASON_INVALID_DF_CTL, "Invalid DF_CTL" }, 307 { FC_REASON_INVALID_SEQ_CNT, "Invalid Sequence count" }, 308 { FC_REASON_INVALID_PARAM, "Invalid Parameter" }, 309 { FC_REASON_EXCH_ERROR, "Exchange Error" }, 310 { FC_REASON_PROTOCOL_ERROR, "Protocol Error" }, 311 { FC_REASON_INCORRECT_LENGTH, "Incorrect Length" }, 312 { FC_REASON_UNEXPECTED_ACK, "Unexpected Ack" }, 313 { FC_REASON_UNEXPECTED_LR, "Unexpected Link reset" }, 314 { FC_REASON_LOGIN_REQUIRED, "Login Required" }, 315 { FC_REASON_EXCESSIVE_SEQS, "Excessive Sequences" 316 " Attempted" }, 317 { FC_REASON_EXCH_UNABLE, "Exchange incapable" }, 318 { FC_REASON_ESH_NOT_SUPP, "Expiration Security Header " 319 "Not Supported" }, 320 { FC_REASON_NO_FABRIC_PATH, "No Fabric Path" }, 321 { FC_REASON_VENDOR_UNIQUE, "Vendor Unique" }, 322 { FC_REASON_INVALID, NULL } 323 }; 324 325 fc_pkt_reason_t n_port_busy_reasons [] = { 326 { FC_REASON_PHYSICAL_BUSY, "Physical Busy" }, 327 { FC_REASON_N_PORT_RESOURCE_BSY, "Resource Busy" }, 328 { FC_REASON_N_PORT_VENDOR_UNIQUE, "Vendor Unique" }, 329 { FC_REASON_INVALID, NULL } 330 }; 331 332 fc_pkt_reason_t f_busy_reasons [] = { 333 { FC_REASON_FABRIC_BSY, "Fabric Busy" }, 334 { FC_REASON_N_PORT_BSY, "N_Port Busy" }, 335 { FC_REASON_INVALID, NULL } 336 }; 337 338 fc_pkt_reason_t ls_ba_rjt_reasons [] = { 339 { FC_REASON_INVALID_LA_CODE, "Invalid Link Application Code" }, 340 { FC_REASON_LOGICAL_ERROR, "Logical Error" }, 341 { FC_REASON_LOGICAL_BSY, "Logical Busy" }, 342 { FC_REASON_PROTOCOL_ERROR_RJT, "Protocol Error Reject" }, 343 { FC_REASON_CMD_UNABLE, "Unable to Perform Command" }, 344 { FC_REASON_CMD_UNSUPPORTED, "Unsupported Command" }, 345 { FC_REASON_VU_RJT, "Vendor Unique" }, 346 { FC_REASON_INVALID, NULL } 347 }; 348 349 fc_pkt_reason_t fs_rjt_reasons [] = { 350 { FC_REASON_FS_INVALID_CMD, "Invalid Command" }, 351 { FC_REASON_FS_INVALID_VER, "Invalid Version" }, 352 { FC_REASON_FS_LOGICAL_ERR, "Logical Error" }, 353 { FC_REASON_FS_INVALID_IUSIZE, "Invalid IU Size" }, 354 { FC_REASON_FS_LOGICAL_BUSY, "Logical Busy" }, 355 { FC_REASON_FS_PROTOCOL_ERR, "Protocol Error" }, 356 { FC_REASON_FS_CMD_UNABLE, "Unable to Perform Command" }, 357 { FC_REASON_FS_CMD_UNSUPPORTED, "Unsupported Command" }, 358 { FC_REASON_FS_VENDOR_UNIQUE, "Vendor Unique" }, 359 { FC_REASON_INVALID, NULL } 360 }; 361 362 fc_pkt_action_t n_port_busy_actions [] = { 363 { FC_ACTION_SEQ_TERM_RETRY, "Retry terminated Sequence" }, 364 { FC_ACTION_SEQ_ACTIVE_RETRY, "Retry Active Sequence" }, 365 { FC_REASON_INVALID, NULL } 366 }; 367 368 fc_pkt_action_t rjt_timeout_actions [] = { 369 { FC_ACTION_RETRYABLE, "Retryable" }, 370 { FC_ACTION_NON_RETRYABLE, "Non Retryable" }, 371 { FC_REASON_INVALID, NULL } 372 }; 373 374 fc_pkt_expln_t ba_rjt_explns [] = { 375 { FC_EXPLN_NONE, "No Explanation" }, 376 { FC_EXPLN_INVALID_OX_RX_ID, "Invalid X_ID" }, 377 { FC_EXPLN_SEQ_ABORTED, "Sequence Aborted" }, 378 { FC_EXPLN_INVALID, NULL } 379 }; 380 381 fc_pkt_error_t fc_pkt_errlist[] = { 382 { 383 FC_PKT_SUCCESS, 384 "Operation Success", 385 NULL, 386 NULL, 387 NULL 388 }, 389 { FC_PKT_REMOTE_STOP, 390 "Remote Stop", 391 remote_stop_reasons, 392 NULL, 393 NULL 394 }, 395 { 396 FC_PKT_LOCAL_RJT, 397 "Local Reject", 398 general_reasons, 399 rjt_timeout_actions, 400 NULL 401 }, 402 { 403 FC_PKT_NPORT_RJT, 404 "N_Port Reject", 405 rjt_reasons, 406 rjt_timeout_actions, 407 NULL 408 }, 409 { 410 FC_PKT_FABRIC_RJT, 411 "Fabric Reject", 412 rjt_reasons, 413 rjt_timeout_actions, 414 NULL 415 }, 416 { 417 FC_PKT_LOCAL_BSY, 418 "Local Busy", 419 general_reasons, 420 NULL, 421 NULL, 422 }, 423 { 424 FC_PKT_TRAN_BSY, 425 "Transport Busy", 426 general_reasons, 427 NULL, 428 NULL, 429 }, 430 { 431 FC_PKT_NPORT_BSY, 432 "N_Port Busy", 433 n_port_busy_reasons, 434 n_port_busy_actions, 435 NULL 436 }, 437 { 438 FC_PKT_FABRIC_BSY, 439 "Fabric Busy", 440 f_busy_reasons, 441 NULL, 442 NULL, 443 }, 444 { 445 FC_PKT_LS_RJT, 446 "Link Service Reject", 447 ls_ba_rjt_reasons, 448 NULL, 449 NULL, 450 }, 451 { 452 FC_PKT_BA_RJT, 453 "Basic Reject", 454 ls_ba_rjt_reasons, 455 NULL, 456 ba_rjt_explns, 457 }, 458 { 459 FC_PKT_TIMEOUT, 460 "Timeout", 461 general_reasons, 462 rjt_timeout_actions, 463 NULL 464 }, 465 { 466 FC_PKT_FS_RJT, 467 "Fabric Switch Reject", 468 fs_rjt_reasons, 469 NULL, 470 NULL 471 }, 472 { 473 FC_PKT_TRAN_ERROR, 474 "Packet Transport error", 475 general_reasons, 476 NULL, 477 NULL 478 }, 479 { 480 FC_PKT_FAILURE, 481 "Packet Failure", 482 general_reasons, 483 NULL, 484 NULL 485 }, 486 { 487 FC_PKT_PORT_OFFLINE, 488 "Port Offline", 489 NULL, 490 NULL, 491 NULL 492 }, 493 { 494 FC_PKT_ELS_IN_PROGRESS, 495 "ELS is in Progress", 496 NULL, 497 NULL, 498 NULL 499 } 500 }; 501 502 int 503 _init() 504 { 505 int rval; 506 507 rw_init(&fctl_ulp_lock, NULL, RW_DRIVER, NULL); 508 rw_init(&fctl_mod_ports_lock, NULL, RW_DRIVER, NULL); 509 mutex_init(&fctl_port_lock, NULL, MUTEX_DRIVER, NULL); 510 mutex_init(&fctl_nwwn_hash_mutex, NULL, MUTEX_DRIVER, NULL); 511 512 fctl_nwwn_hash_table = kmem_zalloc(sizeof (*fctl_nwwn_hash_table) * 513 fctl_nwwn_table_size, KM_SLEEP); 514 515 fctl_ulp_modules = NULL; 516 fctl_fca_portlist = NULL; 517 518 fctl_job_cache = kmem_cache_create("fctl_cache", 519 sizeof (job_request_t), 8, fctl_cache_constructor, 520 fctl_cache_destructor, NULL, NULL, NULL, 0); 521 522 if (fctl_job_cache == NULL) { 523 kmem_free(fctl_nwwn_hash_table, 524 sizeof (*fctl_nwwn_hash_table) * fctl_nwwn_table_size); 525 mutex_destroy(&fctl_nwwn_hash_mutex); 526 mutex_destroy(&fctl_port_lock); 527 rw_destroy(&fctl_ulp_lock); 528 rw_destroy(&fctl_mod_ports_lock); 529 return (ENOMEM); 530 } 531 532 if ((rval = mod_install(&modlinkage)) != 0) { 533 kmem_cache_destroy(fctl_job_cache); 534 kmem_free(fctl_nwwn_hash_table, 535 sizeof (*fctl_nwwn_hash_table) * fctl_nwwn_table_size); 536 mutex_destroy(&fctl_nwwn_hash_mutex); 537 mutex_destroy(&fctl_port_lock); 538 rw_destroy(&fctl_ulp_lock); 539 rw_destroy(&fctl_mod_ports_lock); 540 } 541 542 return (rval); 543 } 544 545 546 /* 547 * The mod_uninstall code doesn't call _fini when 548 * there is living dependent module on fctl. So 549 * there is no need to be extra careful here ? 550 */ 551 int 552 _fini() 553 { 554 int rval; 555 556 if ((rval = mod_remove(&modlinkage)) != 0) { 557 return (rval); 558 } 559 560 kmem_cache_destroy(fctl_job_cache); 561 kmem_free(fctl_nwwn_hash_table, 562 sizeof (*fctl_nwwn_hash_table) * fctl_nwwn_table_size); 563 mutex_destroy(&fctl_nwwn_hash_mutex); 564 mutex_destroy(&fctl_port_lock); 565 rw_destroy(&fctl_ulp_lock); 566 rw_destroy(&fctl_mod_ports_lock); 567 568 return (rval); 569 } 570 571 572 int 573 _info(struct modinfo *modinfo_p) 574 { 575 return (mod_info(&modlinkage, modinfo_p)); 576 } 577 578 579 /* ARGSUSED */ 580 static int 581 fctl_cache_constructor(void *buf, void *cdarg, int kmflag) 582 { 583 job_request_t *job = (job_request_t *)buf; 584 585 mutex_init(&job->job_mutex, NULL, MUTEX_DRIVER, NULL); 586 sema_init(&job->job_fctl_sema, 0, NULL, SEMA_DEFAULT, NULL); 587 sema_init(&job->job_port_sema, 0, NULL, SEMA_DEFAULT, NULL); 588 589 return (0); 590 } 591 592 593 /* ARGSUSED */ 594 static void 595 fctl_cache_destructor(void *buf, void *cdarg) 596 { 597 job_request_t *job = (job_request_t *)buf; 598 599 sema_destroy(&job->job_fctl_sema); 600 sema_destroy(&job->job_port_sema); 601 mutex_destroy(&job->job_mutex); 602 } 603 604 605 /* 606 * fc_ulp_add: 607 * Add a ULP module 608 * 609 * Return Codes: 610 * FC_ULP_SAMEMODULE 611 * FC_SUCCESS 612 * FC_FAILURE 613 * 614 * fc_ulp_add prints a warning message if there is already a 615 * similar ULP type attached and this is unlikely to change as 616 * we trudge along. Further, this function returns a failure 617 * code if the same module attempts to add more than once for 618 * the same FC-4 type. 619 */ 620 int 621 fc_ulp_add(fc_ulp_modinfo_t *ulp_info) 622 { 623 fc_ulp_module_t *mod; 624 fc_ulp_module_t *prev; 625 job_request_t *job; 626 fc_ulp_list_t *new; 627 fc_fca_port_t *fca_port; 628 int ntry = 0; 629 630 ASSERT(ulp_info != NULL); 631 632 /* 633 * Make sure ulp_rev matches fctl version. 634 * Whenever non-private data structure or non-static interface changes, 635 * we should use an increased FCTL_ULP_MODREV_# number here and in all 636 * ulps to prevent version mismatch. 637 */ 638 if (ulp_info->ulp_rev != FCTL_ULP_MODREV_4) { 639 cmn_err(CE_WARN, "fctl: ULP %s version mismatch;" 640 " ULP %s would not be loaded", ulp_info->ulp_name, 641 ulp_info->ulp_name); 642 return (FC_BADULP); 643 } 644 645 new = kmem_zalloc(sizeof (*new), KM_SLEEP); 646 ASSERT(new != NULL); 647 648 mutex_enter(&fctl_ulp_list_mutex); 649 new->ulp_info = ulp_info; 650 if (fctl_ulp_list != NULL) { 651 new->ulp_next = fctl_ulp_list; 652 } 653 fctl_ulp_list = new; 654 mutex_exit(&fctl_ulp_list_mutex); 655 656 while (rw_tryenter(&fctl_ulp_lock, RW_WRITER) == 0) { 657 delay(drv_usectohz(1000000)); 658 if (ntry++ > FC_ULP_ADD_RETRY_COUNT) { 659 fc_ulp_list_t *list; 660 fc_ulp_list_t *last; 661 mutex_enter(&fctl_ulp_list_mutex); 662 for (last = NULL, list = fctl_ulp_list; list != NULL; 663 list = list->ulp_next) { 664 if (list->ulp_info == ulp_info) { 665 break; 666 } 667 last = list; 668 } 669 670 if (list) { 671 if (last) { 672 last->ulp_next = list->ulp_next; 673 } else { 674 fctl_ulp_list = list->ulp_next; 675 } 676 kmem_free(list, sizeof (*list)); 677 } 678 mutex_exit(&fctl_ulp_list_mutex); 679 cmn_err(CE_WARN, "fctl: ULP %s unable to load", 680 ulp_info->ulp_name); 681 return (FC_FAILURE); 682 } 683 } 684 685 for (mod = fctl_ulp_modules, prev = NULL; mod; mod = mod->mod_next) { 686 ASSERT(mod->mod_info != NULL); 687 688 if (ulp_info == mod->mod_info && 689 ulp_info->ulp_type == mod->mod_info->ulp_type) { 690 rw_exit(&fctl_ulp_lock); 691 return (FC_ULP_SAMEMODULE); 692 } 693 694 if (ulp_info->ulp_type == mod->mod_info->ulp_type) { 695 cmn_err(CE_NOTE, fctl_greeting, ulp_info->ulp_name, 696 ulp_info->ulp_type); 697 } 698 prev = mod; 699 } 700 701 mod = kmem_zalloc(sizeof (*mod), KM_SLEEP); 702 mod->mod_info = ulp_info; 703 mod->mod_next = NULL; 704 705 if (prev) { 706 prev->mod_next = mod; 707 } else { 708 fctl_ulp_modules = mod; 709 } 710 711 /* 712 * Schedule a job to each port's job_handler 713 * thread to attach their ports with this ULP. 714 */ 715 mutex_enter(&fctl_port_lock); 716 for (fca_port = fctl_fca_portlist; fca_port != NULL; 717 fca_port = fca_port->port_next) { 718 job = fctl_alloc_job(JOB_ATTACH_ULP, JOB_TYPE_FCTL_ASYNC, 719 NULL, NULL, KM_SLEEP); 720 721 fctl_enque_job(fca_port->port_handle, job); 722 } 723 mutex_exit(&fctl_port_lock); 724 725 rw_exit(&fctl_ulp_lock); 726 727 return (FC_SUCCESS); 728 } 729 730 731 /* 732 * fc_ulp_remove 733 * Remove a ULP module 734 * 735 * A misbehaving ULP may call this routine while I/Os are in progress. 736 * Currently there is no mechanism to detect it to fail such a request. 737 * 738 * Return Codes: 739 * FC_SUCCESS 740 * FC_FAILURE 741 */ 742 int 743 fc_ulp_remove(fc_ulp_modinfo_t *ulp_info) 744 { 745 fc_ulp_module_t *mod; 746 fc_ulp_list_t *list; 747 fc_ulp_list_t *last; 748 fc_ulp_module_t *prev; 749 750 mutex_enter(&fctl_ulp_list_mutex); 751 752 for (last = NULL, list = fctl_ulp_list; list != NULL; 753 list = list->ulp_next) { 754 if (list->ulp_info == ulp_info) { 755 break; 756 } 757 last = list; 758 } 759 760 if (list) { 761 if (last) { 762 last->ulp_next = list->ulp_next; 763 } else { 764 fctl_ulp_list = list->ulp_next; 765 } 766 kmem_free(list, sizeof (*list)); 767 } 768 769 mutex_exit(&fctl_ulp_list_mutex); 770 771 rw_enter(&fctl_ulp_lock, RW_WRITER); 772 773 for (mod = fctl_ulp_modules, prev = NULL; mod != NULL; 774 mod = mod->mod_next) { 775 if (mod->mod_info == ulp_info) { 776 break; 777 } 778 prev = mod; 779 } 780 781 if (mod) { 782 fc_ulp_ports_t *next; 783 784 if (prev) { 785 prev->mod_next = mod->mod_next; 786 } else { 787 fctl_ulp_modules = mod->mod_next; 788 } 789 790 rw_enter(&fctl_mod_ports_lock, RW_WRITER); 791 792 while ((next = mod->mod_ports) != NULL) { 793 mod->mod_ports = next->port_next; 794 fctl_dealloc_ulp_port(next); 795 } 796 797 rw_exit(&fctl_mod_ports_lock); 798 rw_exit(&fctl_ulp_lock); 799 800 kmem_free(mod, sizeof (*mod)); 801 802 return (FC_SUCCESS); 803 } 804 rw_exit(&fctl_ulp_lock); 805 806 return (FC_FAILURE); 807 } 808 809 810 /* 811 * The callers typically cache allocate the packet, complete the 812 * DMA setup for pkt_cmd and pkt_resp fields of the packet and 813 * call this function to see if the FCA is interested in doing 814 * its own intialization. For example, socal may like to initialize 815 * the soc_hdr which is pointed to by the pkt_fca_private field 816 * and sitting right below fc_packet_t in memory. 817 * 818 * The caller is required to ensure that pkt_pd is populated with the 819 * handle that it was given when the transport notified it about the 820 * device this packet is associated with. If there is no associated 821 * device, pkt_pd must be set to NULL. A non-NULL pkt_pd will cause an 822 * increment of the reference count for said pd. When the packet is freed, 823 * the reference count will be decremented. This reference count, in 824 * combination with the PD_GIVEN_TO_ULPS flag guarantees that the pd 825 * will not wink out of existence while there is a packet outstanding. 826 * 827 * This function and fca_init_pkt must not perform any operations that 828 * would result in a call back to the ULP, as the ULP may be required 829 * to hold a mutex across this call to ensure that the pd in question 830 * won't go away prior the call to fc_ulp_transport. 831 * 832 * ULPs are responsible for using the handles they are given during state 833 * change callback processing in a manner that ensures consistency. That 834 * is, they must be aware that they could be processing a state change 835 * notification that tells them the device associated with a particular 836 * handle has gone away at the same time they are being asked to 837 * initialize a packet using that handle. ULPs must therefore ensure 838 * that their state change processing and packet initialization code 839 * paths are sufficiently synchronized to avoid the use of an 840 * invalidated handle in any fc_packet_t struct that is passed to the 841 * fc_ulp_init_packet() function. 842 */ 843 int 844 fc_ulp_init_packet(opaque_t port_handle, fc_packet_t *pkt, int sleep) 845 { 846 int rval; 847 fc_local_port_t *port = port_handle; 848 fc_remote_port_t *pd; 849 850 ASSERT(pkt != NULL); 851 852 pd = pkt->pkt_pd; 853 854 /* Call the FCA driver's fca_init_pkt entry point function. */ 855 rval = port->fp_fca_tran->fca_init_pkt(port->fp_fca_handle, pkt, sleep); 856 857 if ((rval == FC_SUCCESS) && (pd != NULL)) { 858 /* 859 * A !NULL pd here must still be a valid 860 * reference to the fc_remote_port_t. 861 */ 862 mutex_enter(&pd->pd_mutex); 863 ASSERT(pd->pd_ref_count >= 0); 864 pd->pd_ref_count++; 865 mutex_exit(&pd->pd_mutex); 866 } 867 868 return (rval); 869 } 870 871 872 /* 873 * This function is called before destroying the cache allocated 874 * fc_packet to free up (and uninitialize) any resource specially 875 * allocated by the FCA driver during tran_init_pkt(). 876 * 877 * If the pkt_pd field in the given fc_packet_t struct is not NULL, then 878 * the pd_ref_count reference count is decremented for the indicated 879 * fc_remote_port_t struct. 880 */ 881 int 882 fc_ulp_uninit_packet(opaque_t port_handle, fc_packet_t *pkt) 883 { 884 int rval; 885 fc_local_port_t *port = port_handle; 886 fc_remote_port_t *pd; 887 888 ASSERT(pkt != NULL); 889 890 pd = pkt->pkt_pd; 891 892 /* Call the FCA driver's fca_un_init_pkt entry point function */ 893 rval = port->fp_fca_tran->fca_un_init_pkt(port->fp_fca_handle, pkt); 894 895 if ((rval == FC_SUCCESS) && (pd != NULL)) { 896 mutex_enter(&pd->pd_mutex); 897 898 ASSERT(pd->pd_ref_count > 0); 899 pd->pd_ref_count--; 900 901 /* 902 * If at this point the state of this fc_remote_port_t 903 * struct is PORT_DEVICE_INVALID, it probably means somebody 904 * is cleaning up old (e.g. retried) packets. If the 905 * pd_ref_count has also dropped to zero, it's time to 906 * deallocate this fc_remote_port_t struct. 907 */ 908 if (pd->pd_state == PORT_DEVICE_INVALID && 909 pd->pd_ref_count == 0) { 910 fc_remote_node_t *node = pd->pd_remote_nodep; 911 912 mutex_exit(&pd->pd_mutex); 913 914 /* 915 * Also deallocate the associated fc_remote_node_t 916 * struct if it has no other associated 917 * fc_remote_port_t structs. 918 */ 919 if ((fctl_destroy_remote_port(port, pd) == 0) && 920 (node != NULL)) { 921 fctl_destroy_remote_node(node); 922 } 923 return (rval); 924 } 925 926 mutex_exit(&pd->pd_mutex); 927 } 928 929 return (rval); 930 } 931 932 933 int 934 fc_ulp_getportmap(opaque_t port_handle, fc_portmap_t **map, uint32_t *len, 935 int flag) 936 { 937 int job_code; 938 fc_local_port_t *port; 939 job_request_t *job; 940 fc_portmap_t *tmp_map; 941 uint32_t tmp_len; 942 fc_portmap_t *change_list = NULL; 943 uint32_t listlen = 0; 944 945 port = port_handle; 946 947 mutex_enter(&port->fp_mutex); 948 if (port->fp_statec_busy) { 949 mutex_exit(&port->fp_mutex); 950 return (FC_STATEC_BUSY); 951 } 952 953 if (FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) { 954 mutex_exit(&port->fp_mutex); 955 return (FC_OFFLINE); 956 } 957 958 if (port->fp_dev_count && (port->fp_dev_count == 959 port->fp_total_devices)) { 960 mutex_exit(&port->fp_mutex); 961 fctl_fillout_map(port, &change_list, &listlen, 1, 1, 0); 962 if (listlen > *len) { 963 tmp_map = (fc_portmap_t *)kmem_zalloc( 964 listlen * sizeof (fc_portmap_t), KM_NOSLEEP); 965 if (tmp_map == NULL) { 966 return (FC_NOMEM); 967 } 968 if (*map) { 969 kmem_free(*map, (*len) * sizeof (fc_portmap_t)); 970 } 971 *map = tmp_map; 972 } 973 if (change_list) { 974 bcopy(change_list, *map, 975 listlen * sizeof (fc_portmap_t)); 976 kmem_free(change_list, listlen * sizeof (fc_portmap_t)); 977 } 978 *len = listlen; 979 } else { 980 mutex_exit(&port->fp_mutex); 981 982 switch (flag) { 983 case FC_ULP_PLOGI_DONTCARE: 984 job_code = JOB_PORT_GETMAP; 985 break; 986 987 case FC_ULP_PLOGI_PRESERVE: 988 job_code = JOB_PORT_GETMAP_PLOGI_ALL; 989 break; 990 991 default: 992 return (FC_INVALID_REQUEST); 993 } 994 /* 995 * Submit a job request to the job handler 996 * thread to get the map and wait 997 */ 998 job = fctl_alloc_job(job_code, 0, NULL, NULL, KM_SLEEP); 999 job->job_private = (opaque_t)map; 1000 job->job_arg = (opaque_t)len; 1001 fctl_enque_job(port, job); 1002 1003 fctl_jobwait(job); 1004 /* 1005 * The result of the last I/O operation is 1006 * in job_code. We don't care to look at it 1007 * Rather we look at the number of devices 1008 * that are found to fill out the map for 1009 * ULPs. 1010 */ 1011 fctl_dealloc_job(job); 1012 } 1013 1014 /* 1015 * If we're here, we're returning a map to the caller, which means 1016 * we'd better make sure every pd in that map has the 1017 * PD_GIVEN_TO_ULPS flag set. 1018 */ 1019 1020 tmp_len = *len; 1021 tmp_map = *map; 1022 1023 while (tmp_len-- != 0) { 1024 if (tmp_map->map_state != PORT_DEVICE_INVALID) { 1025 fc_remote_port_t *pd = 1026 (fc_remote_port_t *)tmp_map->map_pd; 1027 mutex_enter(&pd->pd_mutex); 1028 pd->pd_aux_flags |= PD_GIVEN_TO_ULPS; 1029 mutex_exit(&pd->pd_mutex); 1030 } 1031 tmp_map++; 1032 } 1033 1034 return (FC_SUCCESS); 1035 } 1036 1037 1038 int 1039 fc_ulp_login(opaque_t port_handle, fc_packet_t **ulp_pkt, uint32_t listlen) 1040 { 1041 int rval = FC_SUCCESS; 1042 int job_flags; 1043 uint32_t count; 1044 fc_packet_t **tmp_array; 1045 job_request_t *job; 1046 fc_local_port_t *port = port_handle; 1047 fc_ulp_rscn_info_t *rscnp = 1048 (fc_ulp_rscn_info_t *)(ulp_pkt[0])->pkt_ulp_rscn_infop; 1049 1050 /* 1051 * If the port is OFFLINE, or if the port driver is 1052 * being SUSPENDED/PM_SUSPENDED/DETACHED, block all 1053 * PLOGI operations 1054 */ 1055 mutex_enter(&port->fp_mutex); 1056 if (port->fp_statec_busy) { 1057 mutex_exit(&port->fp_mutex); 1058 return (FC_STATEC_BUSY); 1059 } 1060 1061 if ((FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) || 1062 (port->fp_soft_state & 1063 (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN))) { 1064 mutex_exit(&port->fp_mutex); 1065 return (FC_OFFLINE); 1066 } 1067 1068 /* 1069 * If the rscn count in the packet is not the same as the rscn count 1070 * in the fc_local_port_t, then one or more new RSCNs has occurred. 1071 */ 1072 if ((rscnp != NULL) && 1073 (rscnp->ulp_rscn_count != FC_INVALID_RSCN_COUNT) && 1074 (rscnp->ulp_rscn_count != port->fp_rscn_count)) { 1075 mutex_exit(&port->fp_mutex); 1076 return (FC_DEVICE_BUSY_NEW_RSCN); 1077 } 1078 1079 mutex_exit(&port->fp_mutex); 1080 1081 tmp_array = kmem_zalloc(sizeof (*tmp_array) * listlen, KM_SLEEP); 1082 for (count = 0; count < listlen; count++) { 1083 tmp_array[count] = ulp_pkt[count]; 1084 } 1085 1086 job_flags = ((ulp_pkt[0]->pkt_tran_flags) & FC_TRAN_NO_INTR) 1087 ? 0 : JOB_TYPE_FCTL_ASYNC; 1088 1089 #ifdef DEBUG 1090 { 1091 int next; 1092 int count; 1093 int polled; 1094 1095 polled = ((ulp_pkt[0]->pkt_tran_flags) & 1096 FC_TRAN_NO_INTR) ? 0 : JOB_TYPE_FCTL_ASYNC; 1097 1098 for (count = 0; count < listlen; count++) { 1099 next = ((ulp_pkt[count]->pkt_tran_flags) 1100 & FC_TRAN_NO_INTR) ? 0 : JOB_TYPE_FCTL_ASYNC; 1101 ASSERT(next == polled); 1102 } 1103 } 1104 #endif 1105 1106 job = fctl_alloc_job(JOB_PLOGI_GROUP, job_flags, NULL, NULL, KM_SLEEP); 1107 job->job_ulp_pkts = tmp_array; 1108 job->job_ulp_listlen = listlen; 1109 1110 while (listlen--) { 1111 fc_packet_t *pkt; 1112 1113 pkt = tmp_array[listlen]; 1114 if (pkt->pkt_pd == NULL) { 1115 pkt->pkt_state = FC_PKT_SUCCESS; 1116 continue; 1117 } 1118 1119 mutex_enter(&pkt->pkt_pd->pd_mutex); 1120 if (pkt->pkt_pd->pd_flags == PD_ELS_IN_PROGRESS || 1121 pkt->pkt_pd->pd_flags == PD_ELS_MARK) { 1122 /* 1123 * Set the packet state and let the port 1124 * driver call the completion routine 1125 * from its thread 1126 */ 1127 mutex_exit(&pkt->pkt_pd->pd_mutex); 1128 pkt->pkt_state = FC_PKT_ELS_IN_PROGRESS; 1129 continue; 1130 } 1131 1132 if (pkt->pkt_pd->pd_state == PORT_DEVICE_INVALID || 1133 pkt->pkt_pd->pd_type == PORT_DEVICE_OLD) { 1134 mutex_exit(&pkt->pkt_pd->pd_mutex); 1135 pkt->pkt_state = FC_PKT_LOCAL_RJT; 1136 continue; 1137 } 1138 mutex_exit(&pkt->pkt_pd->pd_mutex); 1139 pkt->pkt_state = FC_PKT_SUCCESS; 1140 } 1141 1142 fctl_enque_job(port, job); 1143 1144 if (!(job_flags & JOB_TYPE_FCTL_ASYNC)) { 1145 fctl_jobwait(job); 1146 rval = job->job_result; 1147 fctl_dealloc_job(job); 1148 } 1149 1150 return (rval); 1151 } 1152 1153 1154 opaque_t 1155 fc_ulp_get_remote_port(opaque_t port_handle, la_wwn_t *pwwn, int *error, 1156 int create) 1157 { 1158 fc_local_port_t *port; 1159 job_request_t *job; 1160 fc_remote_port_t *pd; 1161 1162 port = port_handle; 1163 pd = fctl_get_remote_port_by_pwwn(port, pwwn); 1164 1165 if (pd != NULL) { 1166 *error = FC_SUCCESS; 1167 /* 1168 * A ULP now knows about this pd, so mark it 1169 */ 1170 mutex_enter(&pd->pd_mutex); 1171 pd->pd_aux_flags |= PD_GIVEN_TO_ULPS; 1172 mutex_exit(&pd->pd_mutex); 1173 return (pd); 1174 } 1175 1176 mutex_enter(&port->fp_mutex); 1177 if (FC_IS_TOP_SWITCH(port->fp_topology) && create) { 1178 uint32_t d_id; 1179 fctl_ns_req_t *ns_cmd; 1180 1181 mutex_exit(&port->fp_mutex); 1182 1183 job = fctl_alloc_job(JOB_NS_CMD, 0, NULL, NULL, KM_SLEEP); 1184 1185 if (job == NULL) { 1186 *error = FC_NOMEM; 1187 return (pd); 1188 } 1189 1190 ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t), 1191 sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t), 1192 0, KM_SLEEP); 1193 1194 if (ns_cmd == NULL) { 1195 fctl_dealloc_job(job); 1196 *error = FC_NOMEM; 1197 return (pd); 1198 } 1199 ns_cmd->ns_cmd_code = NS_GID_PN; 1200 ((ns_req_gid_pn_t *)(ns_cmd->ns_cmd_buf))->pwwn = *pwwn; 1201 1202 job->job_result = FC_SUCCESS; 1203 job->job_private = (void *)ns_cmd; 1204 job->job_counter = 1; 1205 fctl_enque_job(port, job); 1206 fctl_jobwait(job); 1207 1208 if (job->job_result != FC_SUCCESS) { 1209 *error = job->job_result; 1210 fctl_free_ns_cmd(ns_cmd); 1211 fctl_dealloc_job(job); 1212 return (pd); 1213 } 1214 d_id = ((ns_resp_gid_pn_t *)ns_cmd->ns_data_buf)->pid.port_id; 1215 fctl_free_ns_cmd(ns_cmd); 1216 1217 ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gan_t), 1218 sizeof (ns_resp_gan_t), 0, FCTL_NS_CREATE_DEVICE, 1219 KM_SLEEP); 1220 ASSERT(ns_cmd != NULL); 1221 1222 ns_cmd->ns_gan_max = 1; 1223 ns_cmd->ns_cmd_code = NS_GA_NXT; 1224 ns_cmd->ns_gan_sid = FCTL_GAN_START_ID; 1225 ((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.port_id = d_id - 1; 1226 ((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.priv_lilp_posit = 0; 1227 1228 job->job_result = FC_SUCCESS; 1229 job->job_private = (void *)ns_cmd; 1230 job->job_counter = 1; 1231 fctl_enque_job(port, job); 1232 fctl_jobwait(job); 1233 1234 fctl_free_ns_cmd(ns_cmd); 1235 if (job->job_result != FC_SUCCESS) { 1236 *error = job->job_result; 1237 fctl_dealloc_job(job); 1238 return (pd); 1239 } 1240 fctl_dealloc_job(job); 1241 1242 /* 1243 * Check if the port device is created now. 1244 */ 1245 pd = fctl_get_remote_port_by_pwwn(port, pwwn); 1246 1247 if (pd == NULL) { 1248 *error = FC_FAILURE; 1249 } else { 1250 *error = FC_SUCCESS; 1251 1252 /* 1253 * A ULP now knows about this pd, so mark it 1254 */ 1255 mutex_enter(&pd->pd_mutex); 1256 pd->pd_aux_flags |= PD_GIVEN_TO_ULPS; 1257 mutex_exit(&pd->pd_mutex); 1258 } 1259 } else { 1260 mutex_exit(&port->fp_mutex); 1261 *error = FC_FAILURE; 1262 } 1263 1264 return (pd); 1265 } 1266 1267 1268 /* 1269 * If a NS object exists in the host and query is performed 1270 * on that object, we should retrieve it from our basket 1271 * and return it right here, there by saving a request going 1272 * all the up to the Name Server. 1273 */ 1274 int 1275 fc_ulp_port_ns(opaque_t port_handle, opaque_t pd, fc_ns_cmd_t *ns_req) 1276 { 1277 int rval; 1278 int fabric; 1279 job_request_t *job; 1280 fctl_ns_req_t *ns_cmd; 1281 fc_local_port_t *port = port_handle; 1282 1283 mutex_enter(&port->fp_mutex); 1284 fabric = FC_IS_TOP_SWITCH(port->fp_topology) ? 1 : 0; 1285 mutex_exit(&port->fp_mutex); 1286 1287 /* 1288 * Name server query can't be performed for devices not in Fabric 1289 */ 1290 if (!fabric && pd) { 1291 return (FC_BADOBJECT); 1292 } 1293 1294 if (FC_IS_CMD_A_REG(ns_req->ns_cmd)) { 1295 if (pd == NULL) { 1296 rval = fctl_update_host_ns_values(port, ns_req); 1297 if (rval != FC_SUCCESS) { 1298 return (rval); 1299 } 1300 } else { 1301 /* 1302 * Guess what, FC-GS-2 currently prohibits (not 1303 * in the strongest language though) setting of 1304 * NS object values by other ports. But we might 1305 * get that changed to at least accommodate setting 1306 * symbolic node/port names - But if disks/tapes 1307 * were going to provide a method to set these 1308 * values directly (which in turn might register 1309 * with the NS when they come up; yep, for that 1310 * to happen the disks will have to be very well 1311 * behaved Fabric citizen) we won't need to 1312 * register the symbolic port/node names for 1313 * other ports too (rather send down SCSI commands 1314 * to the devices to set the names) 1315 * 1316 * Be that as it may, let's continue to fail 1317 * registration requests for other ports. period. 1318 */ 1319 return (FC_BADOBJECT); 1320 } 1321 1322 if (!fabric) { 1323 return (FC_SUCCESS); 1324 } 1325 } else if (!fabric) { 1326 return (fctl_retrieve_host_ns_values(port, ns_req)); 1327 } 1328 1329 job = fctl_alloc_job(JOB_NS_CMD, 0, NULL, NULL, KM_SLEEP); 1330 ASSERT(job != NULL); 1331 1332 ns_cmd = fctl_alloc_ns_cmd(ns_req->ns_req_len, 1333 ns_req->ns_resp_len, ns_req->ns_resp_len, 0, KM_SLEEP); 1334 ASSERT(ns_cmd != NULL); 1335 ns_cmd->ns_cmd_code = ns_req->ns_cmd; 1336 bcopy(ns_req->ns_req_payload, ns_cmd->ns_cmd_buf, 1337 ns_req->ns_req_len); 1338 1339 job->job_private = (void *)ns_cmd; 1340 fctl_enque_job(port, job); 1341 fctl_jobwait(job); 1342 rval = job->job_result; 1343 1344 if (ns_req->ns_resp_len >= ns_cmd->ns_data_len) { 1345 bcopy(ns_cmd->ns_data_buf, ns_req->ns_resp_payload, 1346 ns_cmd->ns_data_len); 1347 } 1348 bcopy(&ns_cmd->ns_resp_hdr, &ns_req->ns_resp_hdr, 1349 sizeof (fc_ct_header_t)); 1350 1351 fctl_free_ns_cmd(ns_cmd); 1352 fctl_dealloc_job(job); 1353 1354 return (rval); 1355 } 1356 1357 1358 int 1359 fc_ulp_transport(opaque_t port_handle, fc_packet_t *pkt) 1360 { 1361 int rval; 1362 fc_local_port_t *port; 1363 fc_remote_port_t *pd, *newpd; 1364 fc_ulp_rscn_info_t *rscnp = 1365 (fc_ulp_rscn_info_t *)pkt->pkt_ulp_rscn_infop; 1366 1367 port = port_handle; 1368 1369 if (pkt->pkt_tran_flags & FC_TRAN_DUMPING) { 1370 return (port->fp_fca_tran->fca_transport( 1371 port->fp_fca_handle, pkt)); 1372 } 1373 1374 mutex_enter(&port->fp_mutex); 1375 if (port->fp_statec_busy) { 1376 mutex_exit(&port->fp_mutex); 1377 return (FC_STATEC_BUSY); 1378 } 1379 1380 /* A locus of race conditions */ 1381 if (((FC_PORT_STATE_MASK(port->fp_state)) == FC_STATE_OFFLINE) || 1382 (port->fp_soft_state & 1383 (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN))) { 1384 mutex_exit(&port->fp_mutex); 1385 return (FC_OFFLINE); 1386 } 1387 1388 /* 1389 * If the rscn count in the packet is not the same as the rscn count 1390 * in the fc_local_port_t, then one or more new RSCNs has occurred. 1391 */ 1392 if ((rscnp != NULL) && 1393 (rscnp->ulp_rscn_count != FC_INVALID_RSCN_COUNT) && 1394 (rscnp->ulp_rscn_count != port->fp_rscn_count)) { 1395 mutex_exit(&port->fp_mutex); 1396 return (FC_DEVICE_BUSY_NEW_RSCN); 1397 } 1398 1399 pd = pkt->pkt_pd; 1400 if (pd) { 1401 if (pd->pd_type == PORT_DEVICE_OLD || 1402 pd->pd_state == PORT_DEVICE_INVALID) { 1403 1404 newpd = fctl_get_remote_port_by_pwwn_mutex_held(port, 1405 &pd->pd_port_name); 1406 1407 /* 1408 * The remote port (pd) in the packet is no longer 1409 * usable, as the old pd still exists we can use the 1410 * WWN to check if we have a current pd for the device 1411 * we want. Either way we continue with the old logic 1412 * whether we have a new pd or not, as the new pd 1413 * could be bad, or have become unusable. 1414 */ 1415 if ((newpd) && (newpd != pd)) { 1416 1417 /* 1418 * There is a better remote port (pd) to try, 1419 * so we need to fix the reference counts, etc. 1420 */ 1421 mutex_enter(&newpd->pd_mutex); 1422 newpd->pd_ref_count++; 1423 pkt->pkt_pd = newpd; 1424 mutex_exit(&newpd->pd_mutex); 1425 1426 mutex_enter(&pd->pd_mutex); 1427 pd->pd_ref_count--; 1428 if ((pd->pd_state == PORT_DEVICE_INVALID) && 1429 (pd->pd_ref_count == 0)) { 1430 fc_remote_node_t *node = 1431 pd->pd_remote_nodep; 1432 1433 mutex_exit(&pd->pd_mutex); 1434 mutex_exit(&port->fp_mutex); 1435 1436 /* 1437 * This will create another PD hole 1438 * where we have a reference to a pd, 1439 * but someone else could remove it. 1440 */ 1441 if ((fctl_destroy_remote_port(port, pd) 1442 == 0) && (node != NULL)) { 1443 fctl_destroy_remote_node(node); 1444 } 1445 mutex_enter(&port->fp_mutex); 1446 } else { 1447 mutex_exit(&pd->pd_mutex); 1448 } 1449 pd = newpd; 1450 } 1451 } 1452 1453 if (pd->pd_state != PORT_DEVICE_LOGGED_IN) { 1454 rval = (pd->pd_state == PORT_DEVICE_VALID) ? 1455 FC_LOGINREQ : FC_BADDEV; 1456 mutex_exit(&port->fp_mutex); 1457 return (rval); 1458 } 1459 1460 if (pd->pd_flags != PD_IDLE) { 1461 mutex_exit(&port->fp_mutex); 1462 return (FC_DEVICE_BUSY); 1463 } 1464 1465 if (pd->pd_type == PORT_DEVICE_OLD || 1466 pd->pd_state == PORT_DEVICE_INVALID) { 1467 mutex_exit(&port->fp_mutex); 1468 return (FC_BADDEV); 1469 } 1470 1471 } else if (FC_IS_REAL_DEVICE(pkt->pkt_cmd_fhdr.d_id)) { 1472 mutex_exit(&port->fp_mutex); 1473 return (FC_BADPACKET); 1474 } 1475 mutex_exit(&port->fp_mutex); 1476 1477 return (port->fp_fca_tran->fca_transport(port->fp_fca_handle, pkt)); 1478 } 1479 1480 1481 int 1482 fc_ulp_issue_els(opaque_t port_handle, fc_packet_t *pkt) 1483 { 1484 int rval; 1485 fc_local_port_t *port = port_handle; 1486 fc_remote_port_t *pd; 1487 fc_ulp_rscn_info_t *rscnp = 1488 (fc_ulp_rscn_info_t *)pkt->pkt_ulp_rscn_infop; 1489 1490 /* 1491 * If the port is OFFLINE, or if the port driver is 1492 * being SUSPENDED/PM_SUSPENDED/DETACHED, block all 1493 * ELS operations 1494 */ 1495 mutex_enter(&port->fp_mutex); 1496 if ((FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) || 1497 (port->fp_soft_state & 1498 (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN))) { 1499 mutex_exit(&port->fp_mutex); 1500 return (FC_OFFLINE); 1501 } 1502 1503 if (port->fp_statec_busy) { 1504 mutex_exit(&port->fp_mutex); 1505 return (FC_STATEC_BUSY); 1506 } 1507 1508 /* 1509 * If the rscn count in the packet is not the same as the rscn count 1510 * in the fc_local_port_t, then one or more new RSCNs has occurred. 1511 */ 1512 if ((rscnp != NULL) && 1513 (rscnp->ulp_rscn_count != FC_INVALID_RSCN_COUNT) && 1514 (rscnp->ulp_rscn_count != port->fp_rscn_count)) { 1515 mutex_exit(&port->fp_mutex); 1516 return (FC_DEVICE_BUSY_NEW_RSCN); 1517 } 1518 1519 mutex_exit(&port->fp_mutex); 1520 1521 if ((pd = pkt->pkt_pd) != NULL) { 1522 mutex_enter(&pd->pd_mutex); 1523 if (pd->pd_state != PORT_DEVICE_LOGGED_IN) { 1524 rval = (pd->pd_state == PORT_DEVICE_VALID) ? 1525 FC_LOGINREQ : FC_BADDEV; 1526 mutex_exit(&pd->pd_mutex); 1527 return (rval); 1528 } 1529 1530 if (pd->pd_flags != PD_IDLE) { 1531 mutex_exit(&pd->pd_mutex); 1532 return (FC_DEVICE_BUSY); 1533 } 1534 if (pd->pd_type == PORT_DEVICE_OLD || 1535 pd->pd_state == PORT_DEVICE_INVALID) { 1536 mutex_exit(&pd->pd_mutex); 1537 return (FC_BADDEV); 1538 } 1539 mutex_exit(&pd->pd_mutex); 1540 } 1541 1542 return (port->fp_fca_tran->fca_els_send(port->fp_fca_handle, pkt)); 1543 } 1544 1545 1546 int 1547 fc_ulp_uballoc(opaque_t port_handle, uint32_t *count, uint32_t size, 1548 uint32_t type, uint64_t *tokens) 1549 { 1550 fc_local_port_t *port = port_handle; 1551 1552 return (port->fp_fca_tran->fca_ub_alloc(port->fp_fca_handle, 1553 tokens, size, count, type)); 1554 } 1555 1556 1557 int 1558 fc_ulp_ubfree(opaque_t port_handle, uint32_t count, uint64_t *tokens) 1559 { 1560 fc_local_port_t *port = port_handle; 1561 1562 return (port->fp_fca_tran->fca_ub_free(port->fp_fca_handle, 1563 count, tokens)); 1564 } 1565 1566 1567 int 1568 fc_ulp_ubrelease(opaque_t port_handle, uint32_t count, uint64_t *tokens) 1569 { 1570 fc_local_port_t *port = port_handle; 1571 1572 return (port->fp_fca_tran->fca_ub_release(port->fp_fca_handle, 1573 count, tokens)); 1574 } 1575 1576 1577 int 1578 fc_ulp_abort(opaque_t port_handle, fc_packet_t *pkt, int flags) 1579 { 1580 fc_local_port_t *port = port_handle; 1581 1582 return (port->fp_fca_tran->fca_abort(port->fp_fca_handle, pkt, flags)); 1583 } 1584 1585 1586 /* 1587 * Submit an asynchronous request to the job handler if the sleep 1588 * flag is set to KM_NOSLEEP, as such calls could have been made 1589 * in interrupt contexts, and the goal is to avoid busy waiting, 1590 * blocking on a conditional variable, a semaphore or any of the 1591 * synchronization primitives. A noticeable draw back with this 1592 * asynchronous request is that an FC_SUCCESS is returned long 1593 * before the reset is complete (successful or not). 1594 */ 1595 int 1596 fc_ulp_linkreset(opaque_t port_handle, la_wwn_t *pwwn, int sleep) 1597 { 1598 int rval; 1599 fc_local_port_t *port; 1600 job_request_t *job; 1601 1602 port = port_handle; 1603 /* 1604 * Many a times, this function is called from interrupt 1605 * contexts and there have been several dead locks and 1606 * hangs - One of the simplest work arounds is to fib 1607 * if a RESET is in progress. 1608 */ 1609 mutex_enter(&port->fp_mutex); 1610 if (port->fp_soft_state & FP_SOFT_IN_LINK_RESET) { 1611 mutex_exit(&port->fp_mutex); 1612 return (FC_SUCCESS); 1613 } 1614 1615 /* 1616 * Ward off this reset if a state change is in progress. 1617 */ 1618 if (port->fp_statec_busy) { 1619 mutex_exit(&port->fp_mutex); 1620 return (FC_STATEC_BUSY); 1621 } 1622 port->fp_soft_state |= FP_SOFT_IN_LINK_RESET; 1623 mutex_exit(&port->fp_mutex); 1624 1625 if (fctl_busy_port(port) != 0) { 1626 mutex_enter(&port->fp_mutex); 1627 port->fp_soft_state &= ~FP_SOFT_IN_LINK_RESET; 1628 mutex_exit(&port->fp_mutex); 1629 return (FC_FAILURE); 1630 } 1631 1632 if (sleep == KM_SLEEP) { 1633 job = fctl_alloc_job(JOB_LINK_RESET, 0, NULL, NULL, sleep); 1634 ASSERT(job != NULL); 1635 1636 job->job_private = (void *)pwwn; 1637 job->job_counter = 1; 1638 fctl_enque_job(port, job); 1639 fctl_jobwait(job); 1640 1641 mutex_enter(&port->fp_mutex); 1642 port->fp_soft_state &= ~FP_SOFT_IN_LINK_RESET; 1643 mutex_exit(&port->fp_mutex); 1644 1645 fctl_idle_port(port); 1646 1647 rval = job->job_result; 1648 fctl_dealloc_job(job); 1649 } else { 1650 job = fctl_alloc_job(JOB_LINK_RESET, JOB_TYPE_FCTL_ASYNC, 1651 fctl_link_reset_done, port, sleep); 1652 if (job == NULL) { 1653 mutex_enter(&port->fp_mutex); 1654 port->fp_soft_state &= ~FP_SOFT_IN_LINK_RESET; 1655 mutex_exit(&port->fp_mutex); 1656 fctl_idle_port(port); 1657 return (FC_NOMEM); 1658 } 1659 job->job_private = (void *)pwwn; 1660 job->job_counter = 1; 1661 fctl_priority_enque_job(port, job); 1662 rval = FC_SUCCESS; 1663 } 1664 1665 return (rval); 1666 } 1667 1668 1669 int 1670 fc_ulp_port_reset(opaque_t port_handle, uint32_t cmd) 1671 { 1672 int rval = FC_SUCCESS; 1673 fc_local_port_t *port = port_handle; 1674 1675 switch (cmd) { 1676 case FC_RESET_PORT: 1677 rval = port->fp_fca_tran->fca_reset( 1678 port->fp_fca_handle, FC_FCA_LINK_RESET); 1679 break; 1680 1681 case FC_RESET_ADAPTER: 1682 rval = port->fp_fca_tran->fca_reset( 1683 port->fp_fca_handle, FC_FCA_RESET); 1684 break; 1685 1686 case FC_RESET_DUMP: 1687 rval = port->fp_fca_tran->fca_reset( 1688 port->fp_fca_handle, FC_FCA_CORE); 1689 break; 1690 1691 case FC_RESET_CRASH: 1692 rval = port->fp_fca_tran->fca_reset( 1693 port->fp_fca_handle, FC_FCA_RESET_CORE); 1694 break; 1695 1696 default: 1697 rval = FC_FAILURE; 1698 } 1699 1700 return (rval); 1701 } 1702 1703 1704 int 1705 fc_ulp_get_port_login_params(opaque_t port_handle, la_els_logi_t *login_params) 1706 { 1707 fc_local_port_t *port = port_handle; 1708 1709 /* Copy the login parameters */ 1710 *login_params = port->fp_service_params; 1711 return (FC_SUCCESS); 1712 } 1713 1714 1715 int 1716 fc_ulp_get_port_instance(opaque_t port_handle) 1717 { 1718 fc_local_port_t *port = port_handle; 1719 1720 return (port->fp_instance); 1721 } 1722 1723 1724 opaque_t 1725 fc_ulp_get_port_handle(int port_instance) 1726 { 1727 opaque_t port_handle = NULL; 1728 fc_fca_port_t *cur; 1729 1730 mutex_enter(&fctl_port_lock); 1731 for (cur = fctl_fca_portlist; cur; cur = cur->port_next) { 1732 if (cur->port_handle->fp_instance == port_instance) { 1733 port_handle = (opaque_t)cur->port_handle; 1734 break; 1735 } 1736 } 1737 mutex_exit(&fctl_port_lock); 1738 1739 return (port_handle); 1740 } 1741 1742 1743 int 1744 fc_ulp_error(int fc_errno, char **errmsg) 1745 { 1746 return (fctl_error(fc_errno, errmsg)); 1747 } 1748 1749 1750 int 1751 fc_ulp_pkt_error(fc_packet_t *pkt, char **state, char **reason, 1752 char **action, char **expln) 1753 { 1754 return (fctl_pkt_error(pkt, state, reason, action, expln)); 1755 } 1756 1757 1758 /* 1759 * If an ULP by the specified name exists, return FC_SUCCESS, else FC_FAILURE 1760 */ 1761 int 1762 fc_ulp_is_name_present(caddr_t ulp_name) 1763 { 1764 int rval = FC_FAILURE; 1765 fc_ulp_list_t *list; 1766 1767 mutex_enter(&fctl_ulp_list_mutex); 1768 for (list = fctl_ulp_list; list != NULL; list = list->ulp_next) { 1769 if (strcmp(list->ulp_info->ulp_name, ulp_name) == 0) { 1770 rval = FC_SUCCESS; 1771 break; 1772 } 1773 } 1774 mutex_exit(&fctl_ulp_list_mutex); 1775 1776 return (rval); 1777 } 1778 1779 1780 /* 1781 * Return port WWN for a port Identifier 1782 */ 1783 int 1784 fc_ulp_get_pwwn_by_did(opaque_t port_handle, fc_portid_t d_id, la_wwn_t *pwwn) 1785 { 1786 int rval = FC_FAILURE; 1787 fc_remote_port_t *pd; 1788 fc_local_port_t *port = port_handle; 1789 1790 pd = fctl_get_remote_port_by_did(port, d_id.port_id); 1791 if (pd != NULL) { 1792 mutex_enter(&pd->pd_mutex); 1793 *pwwn = pd->pd_port_name; 1794 mutex_exit(&pd->pd_mutex); 1795 rval = FC_SUCCESS; 1796 } 1797 1798 return (rval); 1799 } 1800 1801 1802 /* 1803 * Return a port map for a port WWN 1804 */ 1805 int 1806 fc_ulp_pwwn_to_portmap(opaque_t port_handle, la_wwn_t *bytes, fc_portmap_t *map) 1807 { 1808 fc_local_port_t *port = port_handle; 1809 fc_remote_node_t *node; 1810 fc_remote_port_t *pd; 1811 1812 pd = fctl_get_remote_port_by_pwwn(port, bytes); 1813 if (pd == NULL) { 1814 return (FC_FAILURE); 1815 } 1816 1817 mutex_enter(&pd->pd_mutex); 1818 map->map_pwwn = pd->pd_port_name; 1819 map->map_did = pd->pd_port_id; 1820 map->map_hard_addr = pd->pd_hard_addr; 1821 map->map_state = pd->pd_state; 1822 map->map_type = pd->pd_type; 1823 map->map_flags = 0; 1824 1825 ASSERT(map->map_type <= PORT_DEVICE_DELETE); 1826 1827 bcopy(pd->pd_fc4types, map->map_fc4_types, sizeof (pd->pd_fc4types)); 1828 1829 node = pd->pd_remote_nodep; 1830 mutex_exit(&pd->pd_mutex); 1831 1832 if (node) { 1833 mutex_enter(&node->fd_mutex); 1834 map->map_nwwn = node->fd_node_name; 1835 mutex_exit(&node->fd_mutex); 1836 } 1837 map->map_pd = pd; 1838 1839 return (FC_SUCCESS); 1840 } 1841 1842 1843 opaque_t 1844 fc_ulp_get_fca_device(opaque_t port_handle, fc_portid_t d_id) 1845 { 1846 fc_local_port_t *port = port_handle; 1847 1848 if (port->fp_fca_tran->fca_get_device == NULL) { 1849 return (NULL); 1850 } 1851 1852 return (port->fp_fca_tran->fca_get_device(port->fp_fca_handle, d_id)); 1853 } 1854 1855 1856 int 1857 fc_ulp_port_notify(opaque_t port_handle, uint32_t cmd) 1858 { 1859 int rval = FC_SUCCESS; 1860 fc_local_port_t *port = port_handle; 1861 1862 if (port->fp_fca_tran->fca_notify) { 1863 mutex_enter(&port->fp_mutex); 1864 switch (cmd) { 1865 case FC_NOTIFY_TARGET_MODE: 1866 port->fp_options |= FP_TARGET_MODE; 1867 break; 1868 case FC_NOTIFY_NO_TARGET_MODE: 1869 port->fp_options &= ~FP_TARGET_MODE; 1870 break; 1871 } 1872 mutex_exit(&port->fp_mutex); 1873 rval = port->fp_fca_tran->fca_notify(port->fp_fca_handle, cmd); 1874 } 1875 1876 return (rval); 1877 } 1878 1879 1880 void 1881 fc_ulp_disable_relogin(opaque_t *fc_port, la_wwn_t *pwwn) 1882 { 1883 fc_remote_port_t *pd = 1884 fctl_get_remote_port_by_pwwn((fc_local_port_t *)fc_port, pwwn); 1885 1886 if (pd) { 1887 mutex_enter(&pd->pd_mutex); 1888 pd->pd_aux_flags |= PD_DISABLE_RELOGIN; 1889 mutex_exit(&pd->pd_mutex); 1890 } 1891 } 1892 1893 1894 void 1895 fc_ulp_enable_relogin(opaque_t *fc_port, la_wwn_t *pwwn) 1896 { 1897 fc_remote_port_t *pd = 1898 fctl_get_remote_port_by_pwwn((fc_local_port_t *)fc_port, pwwn); 1899 1900 if (pd) { 1901 mutex_enter(&pd->pd_mutex); 1902 pd->pd_aux_flags &= ~PD_DISABLE_RELOGIN; 1903 mutex_exit(&pd->pd_mutex); 1904 } 1905 } 1906 1907 1908 /* 1909 * fc_fca_init 1910 * Overload the FCA bus_ops vector in its dev_ops with 1911 * fctl_fca_busops to handle all the INITchilds for "sf" 1912 * in one common place. 1913 * 1914 * Should be called from FCA _init routine. 1915 */ 1916 void 1917 fc_fca_init(struct dev_ops *fca_devops_p) 1918 { 1919 #ifndef __lock_lint 1920 fca_devops_p->devo_bus_ops = &fctl_fca_busops; 1921 #endif /* __lock_lint */ 1922 } 1923 1924 1925 /* 1926 * fc_fca_attach 1927 */ 1928 int 1929 fc_fca_attach(dev_info_t *fca_dip, fc_fca_tran_t *tran) 1930 { 1931 /* 1932 * When we are in a position to offer downward compatibility 1933 * we should change the following check to allow lower revision 1934 * of FCAs; But we aren't there right now. 1935 */ 1936 if (tran->fca_version != FCTL_FCA_MODREV_5) { 1937 const char *name = ddi_driver_name(fca_dip); 1938 1939 ASSERT(name != NULL); 1940 1941 cmn_err(CE_WARN, "fctl: FCA %s version mismatch" 1942 " please upgrade %s", name, name); 1943 return (DDI_FAILURE); 1944 } 1945 1946 ddi_set_driver_private(fca_dip, (caddr_t)tran); 1947 return (DDI_SUCCESS); 1948 } 1949 1950 1951 /* 1952 * fc_fca_detach 1953 */ 1954 int 1955 fc_fca_detach(dev_info_t *fca_dip) 1956 { 1957 ddi_set_driver_private(fca_dip, NULL); 1958 return (DDI_SUCCESS); 1959 } 1960 1961 1962 /* 1963 * Check if the frame is a Link response Frame; Handle all cases (P_RJT, 1964 * F_RJT, P_BSY, F_BSY fall into this category). Check also for some Basic 1965 * Link Service responses such as BA_RJT and Extended Link Service response 1966 * such as LS_RJT. If the response is a Link_Data Frame or something that 1967 * this function doesn't understand return FC_FAILURE; Otherwise, fill out 1968 * various fields (state, action, reason, expln) from the response gotten 1969 * in the packet and return FC_SUCCESS. 1970 */ 1971 int 1972 fc_fca_update_errors(fc_packet_t *pkt) 1973 { 1974 int ret = FC_SUCCESS; 1975 1976 switch (pkt->pkt_resp_fhdr.r_ctl) { 1977 case R_CTL_P_RJT: { 1978 uint32_t prjt; 1979 1980 prjt = pkt->pkt_resp_fhdr.ro; 1981 pkt->pkt_state = FC_PKT_NPORT_RJT; 1982 pkt->pkt_action = (prjt & 0xFF000000) >> 24; 1983 pkt->pkt_reason = (prjt & 0xFF0000) >> 16; 1984 break; 1985 } 1986 1987 case R_CTL_F_RJT: { 1988 uint32_t frjt; 1989 1990 frjt = pkt->pkt_resp_fhdr.ro; 1991 pkt->pkt_state = FC_PKT_FABRIC_RJT; 1992 pkt->pkt_action = (frjt & 0xFF000000) >> 24; 1993 pkt->pkt_reason = (frjt & 0xFF0000) >> 16; 1994 break; 1995 } 1996 1997 case R_CTL_P_BSY: { 1998 uint32_t pbsy; 1999 2000 pbsy = pkt->pkt_resp_fhdr.ro; 2001 pkt->pkt_state = FC_PKT_NPORT_BSY; 2002 pkt->pkt_action = (pbsy & 0xFF000000) >> 24; 2003 pkt->pkt_reason = (pbsy & 0xFF0000) >> 16; 2004 break; 2005 } 2006 2007 case R_CTL_F_BSY_LC: 2008 case R_CTL_F_BSY_DF: { 2009 uchar_t fbsy; 2010 2011 fbsy = pkt->pkt_resp_fhdr.type; 2012 pkt->pkt_state = FC_PKT_FABRIC_BSY; 2013 pkt->pkt_reason = (fbsy & 0xF0) >> 4; 2014 break; 2015 } 2016 2017 case R_CTL_LS_BA_RJT: { 2018 uint32_t brjt; 2019 2020 brjt = *(uint32_t *)pkt->pkt_resp; 2021 pkt->pkt_state = FC_PKT_BA_RJT; 2022 pkt->pkt_reason = (brjt & 0xFF0000) >> 16; 2023 pkt->pkt_expln = (brjt & 0xFF00) >> 8; 2024 break; 2025 } 2026 2027 case R_CTL_ELS_RSP: { 2028 la_els_rjt_t *lsrjt; 2029 2030 lsrjt = (la_els_rjt_t *)pkt->pkt_resp; 2031 if (lsrjt->ls_code.ls_code == LA_ELS_RJT) { 2032 pkt->pkt_state = FC_PKT_LS_RJT; 2033 pkt->pkt_reason = lsrjt->reason; 2034 pkt->pkt_action = lsrjt->action; 2035 break; 2036 } 2037 /* FALLTHROUGH */ 2038 } 2039 2040 default: 2041 ret = FC_FAILURE; 2042 break; 2043 } 2044 2045 return (ret); 2046 } 2047 2048 2049 int 2050 fc_fca_error(int fc_errno, char **errmsg) 2051 { 2052 return (fctl_error(fc_errno, errmsg)); 2053 } 2054 2055 2056 int 2057 fc_fca_pkt_error(fc_packet_t *pkt, char **state, char **reason, 2058 char **action, char **expln) 2059 { 2060 return (fctl_pkt_error(pkt, state, reason, action, expln)); 2061 } 2062 2063 2064 /* 2065 * WWN to string goodie. Unpredictable results will happen 2066 * if enough memory isn't supplied in str argument. If you 2067 * are wondering how much does this routine need, it is just 2068 * (2 * WWN size + 1). So for a WWN size of 8 bytes the str 2069 * argument should have atleast 17 bytes allocated. 2070 */ 2071 void 2072 fc_wwn_to_str(la_wwn_t *wwn, caddr_t str) 2073 { 2074 int count; 2075 2076 for (count = 0; count < FCTL_WWN_SIZE(wwn); count++, str += 2) { 2077 (void) sprintf(str, "%02x", wwn->raw_wwn[count]); 2078 } 2079 *str = '\0'; 2080 } 2081 2082 #define FC_ATOB(x) (((x) >= '0' && (x) <= '9') ? ((x) - '0') : \ 2083 ((x) >= 'a' && (x) <= 'f') ? \ 2084 ((x) - 'a' + 10) : ((x) - 'A' + 10)) 2085 2086 void 2087 fc_str_to_wwn(caddr_t str, la_wwn_t *wwn) 2088 { 2089 int count = 0; 2090 uchar_t byte; 2091 2092 while (*str) { 2093 byte = FC_ATOB(*str); 2094 str++; 2095 byte = byte << 4 | FC_ATOB(*str); 2096 str++; 2097 wwn->raw_wwn[count++] = byte; 2098 } 2099 } 2100 2101 /* 2102 * FCA driver's intercepted bus control operations. 2103 */ 2104 static int 2105 fctl_fca_bus_ctl(dev_info_t *fca_dip, dev_info_t *rip, 2106 ddi_ctl_enum_t op, void *arg, void *result) 2107 { 2108 switch (op) { 2109 case DDI_CTLOPS_REPORTDEV: 2110 break; 2111 2112 case DDI_CTLOPS_IOMIN: 2113 break; 2114 2115 case DDI_CTLOPS_INITCHILD: 2116 return (fctl_initchild(fca_dip, (dev_info_t *)arg)); 2117 2118 case DDI_CTLOPS_UNINITCHILD: 2119 return (fctl_uninitchild(fca_dip, (dev_info_t *)arg)); 2120 2121 default: 2122 return (ddi_ctlops(fca_dip, rip, op, arg, result)); 2123 } 2124 2125 return (DDI_SUCCESS); 2126 } 2127 2128 2129 /* 2130 * FCAs indicate the maximum number of ports supported in their 2131 * tran structure. Fail the INITCHILD if the child port number 2132 * is any greater than the maximum number of ports supported 2133 * by the FCA. 2134 */ 2135 static int 2136 fctl_initchild(dev_info_t *fca_dip, dev_info_t *port_dip) 2137 { 2138 int rval; 2139 int port_no; 2140 int port_len; 2141 char name[20]; 2142 fc_fca_tran_t *tran; 2143 dev_info_t *dip; 2144 int portprop; 2145 2146 port_len = sizeof (port_no); 2147 2148 /* physical port do not has this property */ 2149 portprop = ddi_prop_get_int(DDI_DEV_T_ANY, port_dip, 2150 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 2151 "phyport-instance", -1); 2152 2153 if ((portprop == -1) && ndi_dev_is_persistent_node(port_dip)) { 2154 /* 2155 * Clear any addr bindings created by fcode interpreter 2156 * in devi_last_addr so that a ndi_devi_find should never 2157 * return this fcode node. 2158 */ 2159 ddi_set_name_addr(port_dip, NULL); 2160 return (DDI_FAILURE); 2161 } 2162 2163 rval = ddi_prop_op(DDI_DEV_T_ANY, port_dip, PROP_LEN_AND_VAL_BUF, 2164 DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "port", 2165 (caddr_t)&port_no, &port_len); 2166 2167 if (rval != DDI_SUCCESS) { 2168 return (DDI_FAILURE); 2169 } 2170 2171 tran = (fc_fca_tran_t *)ddi_get_driver_private(fca_dip); 2172 ASSERT(tran != NULL); 2173 2174 (void) sprintf((char *)name, "%x,0", port_no); 2175 ddi_set_name_addr(port_dip, name); 2176 2177 dip = ndi_devi_find(fca_dip, ddi_binding_name(port_dip), name); 2178 2179 /* 2180 * Even though we never initialize FCode nodes of fp, such a node 2181 * could still be there after a DR operation. There will only be 2182 * one FCode node, so if this is the one, clear it and issue a 2183 * ndi_devi_find again. 2184 */ 2185 if ((portprop == -1) && dip && ndi_dev_is_persistent_node(dip)) { 2186 ddi_set_name_addr(dip, NULL); 2187 dip = ndi_devi_find(fca_dip, ddi_binding_name(port_dip), name); 2188 } 2189 2190 if ((portprop == -1) && dip && (dip != port_dip)) { 2191 /* 2192 * Here we have a duplicate .conf entry. Clear the addr 2193 * set previously and return failure. 2194 */ 2195 ddi_set_name_addr(port_dip, NULL); 2196 return (DDI_FAILURE); 2197 } 2198 2199 return (DDI_SUCCESS); 2200 } 2201 2202 2203 /* ARGSUSED */ 2204 static int 2205 fctl_uninitchild(dev_info_t *fca_dip, dev_info_t *port_dip) 2206 { 2207 ddi_set_name_addr(port_dip, NULL); 2208 return (DDI_SUCCESS); 2209 } 2210 2211 2212 static dev_info_t * 2213 fctl_findchild(dev_info_t *pdip, char *cname, char *caddr) 2214 { 2215 dev_info_t *dip; 2216 char *addr; 2217 2218 ASSERT(cname != NULL && caddr != NULL); 2219 /* ASSERT(DEVI_BUSY_OWNED(pdip)); */ 2220 2221 for (dip = ddi_get_child(pdip); dip != NULL; 2222 dip = ddi_get_next_sibling(dip)) { 2223 if (strcmp(cname, ddi_node_name(dip)) != 0) { 2224 continue; 2225 } 2226 2227 if ((addr = ddi_get_name_addr(dip)) == NULL) { 2228 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 2229 DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, 2230 "bus-addr", &addr) == DDI_PROP_SUCCESS) { 2231 if (strcmp(caddr, addr) == 0) { 2232 ddi_prop_free(addr); 2233 return (dip); 2234 } 2235 ddi_prop_free(addr); 2236 } 2237 } else { 2238 if (strcmp(caddr, addr) == 0) { 2239 return (dip); 2240 } 2241 } 2242 } 2243 2244 return (NULL); 2245 } 2246 2247 int 2248 fctl_check_npiv_portindex(dev_info_t *dip, int vindex) 2249 { 2250 int i, instance; 2251 fc_local_port_t *port; 2252 2253 instance = ddi_get_instance(dip); 2254 port = (fc_local_port_t *)fc_ulp_get_port_handle(instance); 2255 if ((!port) || (vindex <= 0) || (vindex >= FC_NPIV_MAX_PORT)) { 2256 return (0); 2257 } 2258 2259 i = vindex-1; 2260 mutex_enter(&port->fp_mutex); 2261 if (port->fp_npiv_portindex[i] == 0) { 2262 mutex_exit(&port->fp_mutex); 2263 return (vindex); 2264 } 2265 mutex_exit(&port->fp_mutex); 2266 return (0); 2267 } 2268 2269 int 2270 fctl_get_npiv_portindex(dev_info_t *dip) 2271 { 2272 int i, instance; 2273 fc_local_port_t *port; 2274 2275 instance = ddi_get_instance(dip); 2276 port = (fc_local_port_t *)fc_ulp_get_port_handle(instance); 2277 if (!port) { 2278 return (0); 2279 } 2280 2281 mutex_enter(&port->fp_mutex); 2282 for (i = 0; i < FC_NPIV_MAX_PORT; i++) { 2283 if (port->fp_npiv_portindex[i] == 0) { 2284 mutex_exit(&port->fp_mutex); 2285 return (i+1); 2286 } 2287 } 2288 mutex_exit(&port->fp_mutex); 2289 return (0); 2290 } 2291 2292 2293 void 2294 fctl_set_npiv_portindex(dev_info_t *dip, int index) 2295 { 2296 int instance; 2297 fc_local_port_t *port; 2298 2299 instance = ddi_get_instance(dip); 2300 port = (fc_local_port_t *)fc_ulp_get_port_handle(instance); 2301 if (!port) { 2302 return; 2303 } 2304 mutex_enter(&port->fp_mutex); 2305 port->fp_npiv_portindex[index - 1] = 1; 2306 mutex_exit(&port->fp_mutex); 2307 } 2308 2309 2310 int 2311 fctl_fca_create_npivport(dev_info_t *parent, 2312 dev_info_t *phydip, char *nname, char *pname, uint32_t *vindex) 2313 { 2314 int rval = 0, devstrlen; 2315 char *devname, *cname, *caddr, *devstr; 2316 dev_info_t *child = NULL; 2317 int portnum; 2318 2319 if (*vindex == 0) { 2320 portnum = fctl_get_npiv_portindex(phydip); 2321 *vindex = portnum; 2322 } else { 2323 portnum = fctl_check_npiv_portindex(phydip, *vindex); 2324 } 2325 2326 if (portnum == 0) { 2327 cmn_err(CE_WARN, 2328 "Cann't find valid port index, fail to create devnode"); 2329 return (NDI_FAILURE); 2330 } 2331 2332 devname = kmem_zalloc(MAXNAMELEN, KM_SLEEP); 2333 (void) sprintf(devname, "fp@%x,0", portnum); 2334 devstrlen = strlen(devname) + 1; 2335 devstr = i_ddi_strdup(devname, KM_SLEEP); 2336 i_ddi_parse_name(devstr, &cname, &caddr, NULL); 2337 2338 if (fctl_findchild(parent, cname, caddr) != NULL) { 2339 rval = NDI_FAILURE; 2340 goto freememory; 2341 } 2342 2343 ndi_devi_alloc_sleep(parent, cname, DEVI_PSEUDO_NODEID, &child); 2344 if (child == NULL) { 2345 cmn_err(CE_WARN, 2346 "fctl_create_npiv_port fail to create new devinfo"); 2347 rval = NDI_FAILURE; 2348 goto freememory; 2349 } 2350 2351 if (ndi_prop_update_string(DDI_DEV_T_NONE, child, 2352 "bus-addr", caddr) != DDI_PROP_SUCCESS) { 2353 cmn_err(CE_WARN, "fctl%d: prop update bus-addr %s@%s failed", 2354 ddi_get_instance(parent), cname, caddr); 2355 (void) ndi_devi_free(child); 2356 rval = NDI_FAILURE; 2357 goto freememory; 2358 } 2359 2360 if (strlen(nname) != 0) { 2361 if (ndi_prop_update_string(DDI_DEV_T_NONE, child, 2362 "node-name", nname) != DDI_PROP_SUCCESS) { 2363 (void) ndi_devi_free(child); 2364 rval = NDI_FAILURE; 2365 goto freememory; 2366 } 2367 } 2368 2369 if (strlen(pname) != 0) { 2370 if (ndi_prop_update_string(DDI_DEV_T_NONE, child, 2371 "port-name", pname) != DDI_PROP_SUCCESS) { 2372 (void) ndi_devi_free(child); 2373 rval = NDI_FAILURE; 2374 goto freememory; 2375 } 2376 } 2377 2378 if (ddi_prop_update_int(DDI_DEV_T_NONE, child, 2379 "port", portnum) != DDI_PROP_SUCCESS) { 2380 cmn_err(CE_WARN, "fp%d: prop_update port %s@%s failed", 2381 ddi_get_instance(parent), cname, caddr); 2382 (void) ndi_devi_free(child); 2383 rval = NDI_FAILURE; 2384 goto freememory; 2385 } 2386 2387 if (ddi_prop_update_int(DDI_DEV_T_NONE, child, 2388 "phyport-instance", ddi_get_instance(phydip)) != DDI_PROP_SUCCESS) { 2389 cmn_err(CE_WARN, 2390 "fp%d: prop_update phyport-instance %s@%s failed", 2391 ddi_get_instance(parent), cname, caddr); 2392 (void) ndi_devi_free(child); 2393 rval = NDI_FAILURE; 2394 goto freememory; 2395 } 2396 2397 rval = ndi_devi_online(child, NDI_ONLINE_ATTACH); 2398 if (rval != NDI_SUCCESS) { 2399 cmn_err(CE_WARN, "fp%d: online_driver %s failed", 2400 ddi_get_instance(parent), cname); 2401 rval = NDI_FAILURE; 2402 goto freememory; 2403 } 2404 2405 fctl_set_npiv_portindex(phydip, portnum); 2406 freememory: 2407 kmem_free(devstr, devstrlen); 2408 kmem_free(devname, MAXNAMELEN); 2409 2410 return (rval); 2411 } 2412 2413 2414 void 2415 fctl_add_port(fc_local_port_t *port) 2416 { 2417 fc_fca_port_t *new; 2418 2419 new = kmem_zalloc(sizeof (*new), KM_SLEEP); 2420 2421 mutex_enter(&fctl_port_lock); 2422 new->port_handle = port; 2423 new->port_next = fctl_fca_portlist; 2424 fctl_fca_portlist = new; 2425 mutex_exit(&fctl_port_lock); 2426 } 2427 2428 2429 void 2430 fctl_remove_port(fc_local_port_t *port) 2431 { 2432 fc_ulp_module_t *mod; 2433 fc_fca_port_t *prev; 2434 fc_fca_port_t *list; 2435 fc_ulp_ports_t *ulp_port; 2436 2437 rw_enter(&fctl_ulp_lock, RW_WRITER); 2438 rw_enter(&fctl_mod_ports_lock, RW_WRITER); 2439 2440 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 2441 ulp_port = fctl_get_ulp_port(mod, port); 2442 if (ulp_port == NULL) { 2443 continue; 2444 } 2445 2446 #ifndef __lock_lint 2447 ASSERT((ulp_port->port_dstate & ULP_PORT_ATTACH) == 0); 2448 #endif /* __lock_lint */ 2449 2450 (void) fctl_remove_ulp_port(mod, port); 2451 } 2452 2453 rw_exit(&fctl_mod_ports_lock); 2454 rw_exit(&fctl_ulp_lock); 2455 2456 mutex_enter(&fctl_port_lock); 2457 2458 list = fctl_fca_portlist; 2459 prev = NULL; 2460 while (list != NULL) { 2461 if (list->port_handle == port) { 2462 if (prev == NULL) { 2463 fctl_fca_portlist = list->port_next; 2464 } else { 2465 prev->port_next = list->port_next; 2466 } 2467 kmem_free(list, sizeof (*list)); 2468 break; 2469 } 2470 prev = list; 2471 list = list->port_next; 2472 } 2473 mutex_exit(&fctl_port_lock); 2474 } 2475 2476 2477 void 2478 fctl_attach_ulps(fc_local_port_t *port, fc_attach_cmd_t cmd, 2479 struct modlinkage *linkage) 2480 { 2481 int rval; 2482 uint32_t s_id; 2483 uint32_t state; 2484 fc_ulp_module_t *mod; 2485 fc_ulp_port_info_t info; 2486 fc_ulp_ports_t *ulp_port; 2487 2488 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 2489 2490 info.port_linkage = linkage; 2491 info.port_dip = port->fp_port_dip; 2492 info.port_handle = (opaque_t)port; 2493 info.port_dma_behavior = port->fp_dma_behavior; 2494 info.port_fcp_dma = port->fp_fcp_dma; 2495 info.port_acc_attr = port->fp_fca_tran->fca_acc_attr; 2496 info.port_fca_pkt_size = port->fp_fca_tran->fca_pkt_size; 2497 info.port_reset_action = port->fp_reset_action; 2498 2499 mutex_enter(&port->fp_mutex); 2500 2501 /* 2502 * It is still possible that another thread could have gotten 2503 * into the detach process before we got here. 2504 */ 2505 if (port->fp_soft_state & FP_SOFT_IN_DETACH) { 2506 mutex_exit(&port->fp_mutex); 2507 return; 2508 } 2509 2510 s_id = port->fp_port_id.port_id; 2511 if (port->fp_statec_busy) { 2512 info.port_state = port->fp_bind_state; 2513 } else { 2514 info.port_state = port->fp_state; 2515 } 2516 2517 switch (state = FC_PORT_STATE_MASK(info.port_state)) { 2518 case FC_STATE_LOOP: 2519 case FC_STATE_NAMESERVICE: 2520 info.port_state &= ~state; 2521 info.port_state |= FC_STATE_ONLINE; 2522 break; 2523 2524 default: 2525 break; 2526 } 2527 ASSERT((info.port_state & FC_STATE_LOOP) == 0); 2528 2529 info.port_flags = port->fp_topology; 2530 info.port_pwwn = port->fp_service_params.nport_ww_name; 2531 info.port_nwwn = port->fp_service_params.node_ww_name; 2532 mutex_exit(&port->fp_mutex); 2533 2534 rw_enter(&fctl_ulp_lock, RW_READER); 2535 rw_enter(&fctl_mod_ports_lock, RW_WRITER); 2536 2537 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 2538 if ((port->fp_soft_state & FP_SOFT_FCA_IS_NODMA) && 2539 (mod->mod_info->ulp_type == FC_TYPE_IS8802_SNAP)) { 2540 /* 2541 * We don't support IP over FC on FCOE HBA 2542 */ 2543 continue; 2544 } 2545 2546 if ((ulp_port = fctl_get_ulp_port(mod, port)) == NULL) { 2547 ulp_port = fctl_add_ulp_port(mod, port, KM_SLEEP); 2548 ASSERT(ulp_port != NULL); 2549 2550 mutex_enter(&ulp_port->port_mutex); 2551 ulp_port->port_statec = ((info.port_state & 2552 FC_STATE_ONLINE) ? FC_ULP_STATEC_ONLINE : 2553 FC_ULP_STATEC_OFFLINE); 2554 mutex_exit(&ulp_port->port_mutex); 2555 } 2556 } 2557 2558 rw_downgrade(&fctl_mod_ports_lock); 2559 2560 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 2561 if ((port->fp_soft_state & FP_SOFT_FCA_IS_NODMA) && 2562 (mod->mod_info->ulp_type == FC_TYPE_IS8802_SNAP)) { 2563 /* 2564 * We don't support IP over FC on FCOE HBA 2565 */ 2566 continue; 2567 } 2568 2569 ulp_port = fctl_get_ulp_port(mod, port); 2570 ASSERT(ulp_port != NULL); 2571 2572 if (fctl_pre_attach(ulp_port, cmd) == FC_FAILURE) { 2573 continue; 2574 } 2575 2576 fctl_init_dma_attr(port, mod, &info); 2577 2578 rval = mod->mod_info->ulp_port_attach( 2579 mod->mod_info->ulp_handle, &info, cmd, s_id); 2580 2581 fctl_post_attach(mod, ulp_port, cmd, rval); 2582 2583 if (rval == FC_SUCCESS && cmd == FC_CMD_ATTACH && 2584 strcmp(mod->mod_info->ulp_name, "fcp") == 0) { 2585 ASSERT(ddi_get_driver_private(info.port_dip) != NULL); 2586 } 2587 } 2588 2589 rw_exit(&fctl_mod_ports_lock); 2590 rw_exit(&fctl_ulp_lock); 2591 } 2592 2593 2594 static int 2595 fctl_pre_attach(fc_ulp_ports_t *ulp_port, fc_attach_cmd_t cmd) 2596 { 2597 int rval = FC_SUCCESS; 2598 2599 mutex_enter(&ulp_port->port_mutex); 2600 2601 switch (cmd) { 2602 case FC_CMD_ATTACH: 2603 if (ulp_port->port_dstate & ULP_PORT_ATTACH) { 2604 rval = FC_FAILURE; 2605 } 2606 break; 2607 2608 case FC_CMD_RESUME: 2609 ASSERT((ulp_port->port_dstate & ULP_PORT_POWER_DOWN) == 0); 2610 if (!(ulp_port->port_dstate & ULP_PORT_ATTACH) || 2611 !(ulp_port->port_dstate & ULP_PORT_SUSPEND)) { 2612 rval = FC_FAILURE; 2613 } 2614 break; 2615 2616 case FC_CMD_POWER_UP: 2617 if (!(ulp_port->port_dstate & ULP_PORT_ATTACH) || 2618 !(ulp_port->port_dstate & ULP_PORT_POWER_DOWN)) { 2619 rval = FC_FAILURE; 2620 } 2621 break; 2622 } 2623 2624 if (rval == FC_SUCCESS) { 2625 ulp_port->port_dstate |= ULP_PORT_BUSY; 2626 } 2627 mutex_exit(&ulp_port->port_mutex); 2628 2629 return (rval); 2630 } 2631 2632 2633 static void 2634 fctl_post_attach(fc_ulp_module_t *mod, fc_ulp_ports_t *ulp_port, 2635 fc_attach_cmd_t cmd, int rval) 2636 { 2637 int be_chatty; 2638 2639 ASSERT(cmd == FC_CMD_ATTACH || cmd == FC_CMD_RESUME || 2640 cmd == FC_CMD_POWER_UP); 2641 2642 mutex_enter(&ulp_port->port_mutex); 2643 ulp_port->port_dstate &= ~ULP_PORT_BUSY; 2644 2645 be_chatty = (rval == FC_FAILURE_SILENT) ? 0 : 1; 2646 2647 if (rval != FC_SUCCESS) { 2648 caddr_t op; 2649 fc_local_port_t *port = ulp_port->port_handle; 2650 2651 mutex_exit(&ulp_port->port_mutex); 2652 2653 switch (cmd) { 2654 case FC_CMD_ATTACH: 2655 op = "attach"; 2656 break; 2657 2658 case FC_CMD_RESUME: 2659 op = "resume"; 2660 break; 2661 2662 case FC_CMD_POWER_UP: 2663 op = "power up"; 2664 break; 2665 } 2666 2667 if (be_chatty) { 2668 cmn_err(CE_WARN, "!fctl(%d): %s failed for %s", 2669 port->fp_instance, op, mod->mod_info->ulp_name); 2670 } 2671 2672 return; 2673 } 2674 2675 switch (cmd) { 2676 case FC_CMD_ATTACH: 2677 ulp_port->port_dstate |= ULP_PORT_ATTACH; 2678 break; 2679 2680 case FC_CMD_RESUME: 2681 ulp_port->port_dstate &= ~ULP_PORT_SUSPEND; 2682 break; 2683 2684 case FC_CMD_POWER_UP: 2685 ulp_port->port_dstate &= ~ULP_PORT_POWER_DOWN; 2686 break; 2687 } 2688 mutex_exit(&ulp_port->port_mutex); 2689 } 2690 2691 2692 int 2693 fctl_detach_ulps(fc_local_port_t *port, fc_detach_cmd_t cmd, 2694 struct modlinkage *linkage) 2695 { 2696 int rval = FC_SUCCESS; 2697 fc_ulp_module_t *mod; 2698 fc_ulp_port_info_t info; 2699 fc_ulp_ports_t *ulp_port; 2700 2701 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 2702 2703 info.port_linkage = linkage; 2704 info.port_dip = port->fp_port_dip; 2705 info.port_handle = (opaque_t)port; 2706 info.port_acc_attr = port->fp_fca_tran->fca_acc_attr; 2707 info.port_fca_pkt_size = port->fp_fca_tran->fca_pkt_size; 2708 2709 rw_enter(&fctl_ulp_lock, RW_READER); 2710 rw_enter(&fctl_mod_ports_lock, RW_READER); 2711 2712 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 2713 if ((ulp_port = fctl_get_ulp_port(mod, port)) == NULL) { 2714 continue; 2715 } 2716 2717 if (fctl_pre_detach(ulp_port, cmd) != FC_SUCCESS) { 2718 continue; 2719 } 2720 2721 fctl_init_dma_attr(port, mod, &info); 2722 2723 rval = mod->mod_info->ulp_port_detach( 2724 mod->mod_info->ulp_handle, &info, cmd); 2725 2726 fctl_post_detach(mod, ulp_port, cmd, rval); 2727 2728 if (rval != FC_SUCCESS) { 2729 break; 2730 } 2731 2732 if (cmd == FC_CMD_DETACH && strcmp(mod->mod_info->ulp_name, 2733 "fcp") == 0) { 2734 ASSERT(ddi_get_driver_private(info.port_dip) == NULL); 2735 } 2736 2737 mutex_enter(&ulp_port->port_mutex); 2738 ulp_port->port_statec = FC_ULP_STATEC_DONT_CARE; 2739 mutex_exit(&ulp_port->port_mutex); 2740 } 2741 2742 rw_exit(&fctl_mod_ports_lock); 2743 rw_exit(&fctl_ulp_lock); 2744 2745 return (rval); 2746 } 2747 2748 static void 2749 fctl_init_dma_attr(fc_local_port_t *port, fc_ulp_module_t *mod, 2750 fc_ulp_port_info_t *info) 2751 { 2752 2753 if ((strcmp(mod->mod_info->ulp_name, "fcp") == 0) || 2754 (strcmp(mod->mod_info->ulp_name, "ltct") == 0)) { 2755 info->port_cmd_dma_attr = 2756 port->fp_fca_tran->fca_dma_fcp_cmd_attr; 2757 info->port_data_dma_attr = 2758 port->fp_fca_tran->fca_dma_fcp_data_attr; 2759 info->port_resp_dma_attr = 2760 port->fp_fca_tran->fca_dma_fcp_rsp_attr; 2761 } else if (strcmp(mod->mod_info->ulp_name, "fcsm") == 0) { 2762 info->port_cmd_dma_attr = 2763 port->fp_fca_tran->fca_dma_fcsm_cmd_attr; 2764 info->port_data_dma_attr = 2765 port->fp_fca_tran->fca_dma_attr; 2766 info->port_resp_dma_attr = 2767 port->fp_fca_tran->fca_dma_fcsm_rsp_attr; 2768 } else if (strcmp(mod->mod_info->ulp_name, "fcip") == 0) { 2769 info->port_cmd_dma_attr = 2770 port->fp_fca_tran->fca_dma_fcip_cmd_attr; 2771 info->port_data_dma_attr = 2772 port->fp_fca_tran->fca_dma_attr; 2773 info->port_resp_dma_attr = 2774 port->fp_fca_tran->fca_dma_fcip_rsp_attr; 2775 } else { 2776 info->port_cmd_dma_attr = info->port_data_dma_attr = 2777 info->port_resp_dma_attr = 2778 port->fp_fca_tran->fca_dma_attr; /* default */ 2779 } 2780 } 2781 2782 static int 2783 fctl_pre_detach(fc_ulp_ports_t *ulp_port, fc_detach_cmd_t cmd) 2784 { 2785 int rval = FC_SUCCESS; 2786 2787 mutex_enter(&ulp_port->port_mutex); 2788 2789 switch (cmd) { 2790 case FC_CMD_DETACH: 2791 if ((ulp_port->port_dstate & ULP_PORT_ATTACH) == 0) { 2792 rval = FC_FAILURE; 2793 } 2794 break; 2795 2796 case FC_CMD_SUSPEND: 2797 if (!(ulp_port->port_dstate & ULP_PORT_ATTACH) || 2798 ulp_port->port_dstate & ULP_PORT_SUSPEND) { 2799 rval = FC_FAILURE; 2800 } 2801 break; 2802 2803 case FC_CMD_POWER_DOWN: 2804 if (!(ulp_port->port_dstate & ULP_PORT_ATTACH) || 2805 ulp_port->port_dstate & ULP_PORT_POWER_DOWN) { 2806 rval = FC_FAILURE; 2807 } 2808 break; 2809 } 2810 2811 if (rval == FC_SUCCESS) { 2812 ulp_port->port_dstate |= ULP_PORT_BUSY; 2813 } 2814 mutex_exit(&ulp_port->port_mutex); 2815 2816 return (rval); 2817 } 2818 2819 2820 static void 2821 fctl_post_detach(fc_ulp_module_t *mod, fc_ulp_ports_t *ulp_port, 2822 fc_detach_cmd_t cmd, int rval) 2823 { 2824 ASSERT(cmd == FC_CMD_DETACH || cmd == FC_CMD_SUSPEND || 2825 cmd == FC_CMD_POWER_DOWN); 2826 2827 mutex_enter(&ulp_port->port_mutex); 2828 ulp_port->port_dstate &= ~ULP_PORT_BUSY; 2829 2830 if (rval != FC_SUCCESS) { 2831 caddr_t op; 2832 fc_local_port_t *port = ulp_port->port_handle; 2833 2834 mutex_exit(&ulp_port->port_mutex); 2835 2836 switch (cmd) { 2837 case FC_CMD_DETACH: 2838 op = "detach"; 2839 break; 2840 2841 case FC_CMD_SUSPEND: 2842 op = "suspend"; 2843 break; 2844 2845 case FC_CMD_POWER_DOWN: 2846 op = "power down"; 2847 break; 2848 } 2849 2850 cmn_err(CE_WARN, "!fctl(%d): %s failed for %s", 2851 port->fp_instance, op, mod->mod_info->ulp_name); 2852 2853 return; 2854 } 2855 2856 switch (cmd) { 2857 case FC_CMD_DETACH: 2858 ulp_port->port_dstate &= ~ULP_PORT_ATTACH; 2859 break; 2860 2861 case FC_CMD_SUSPEND: 2862 ulp_port->port_dstate |= ULP_PORT_SUSPEND; 2863 break; 2864 2865 case FC_CMD_POWER_DOWN: 2866 ulp_port->port_dstate |= ULP_PORT_POWER_DOWN; 2867 break; 2868 } 2869 mutex_exit(&ulp_port->port_mutex); 2870 } 2871 2872 2873 static fc_ulp_ports_t * 2874 fctl_add_ulp_port(fc_ulp_module_t *ulp_module, fc_local_port_t *port_handle, 2875 int sleep) 2876 { 2877 fc_ulp_ports_t *last; 2878 fc_ulp_ports_t *next; 2879 fc_ulp_ports_t *new; 2880 2881 ASSERT(RW_READ_HELD(&fctl_ulp_lock)); 2882 ASSERT(RW_WRITE_HELD(&fctl_mod_ports_lock)); 2883 2884 last = NULL; 2885 next = ulp_module->mod_ports; 2886 2887 while (next != NULL) { 2888 last = next; 2889 next = next->port_next; 2890 } 2891 2892 new = fctl_alloc_ulp_port(sleep); 2893 if (new == NULL) { 2894 return (new); 2895 } 2896 2897 new->port_handle = port_handle; 2898 if (last == NULL) { 2899 ulp_module->mod_ports = new; 2900 } else { 2901 last->port_next = new; 2902 } 2903 2904 return (new); 2905 } 2906 2907 2908 static fc_ulp_ports_t * 2909 fctl_alloc_ulp_port(int sleep) 2910 { 2911 fc_ulp_ports_t *new; 2912 2913 new = kmem_zalloc(sizeof (*new), sleep); 2914 if (new == NULL) { 2915 return (new); 2916 } 2917 mutex_init(&new->port_mutex, NULL, MUTEX_DRIVER, NULL); 2918 2919 return (new); 2920 } 2921 2922 2923 static int 2924 fctl_remove_ulp_port(struct ulp_module *ulp_module, 2925 fc_local_port_t *port_handle) 2926 { 2927 fc_ulp_ports_t *last; 2928 fc_ulp_ports_t *next; 2929 2930 ASSERT(RW_WRITE_HELD(&fctl_ulp_lock)); 2931 ASSERT(RW_WRITE_HELD(&fctl_mod_ports_lock)); 2932 2933 last = NULL; 2934 next = ulp_module->mod_ports; 2935 2936 while (next != NULL) { 2937 if (next->port_handle == port_handle) { 2938 if (next->port_dstate & ULP_PORT_ATTACH) { 2939 return (FC_FAILURE); 2940 } 2941 break; 2942 } 2943 last = next; 2944 next = next->port_next; 2945 } 2946 2947 if (next != NULL) { 2948 ASSERT((next->port_dstate & ULP_PORT_ATTACH) == 0); 2949 2950 if (last == NULL) { 2951 ulp_module->mod_ports = next->port_next; 2952 } else { 2953 last->port_next = next->port_next; 2954 } 2955 fctl_dealloc_ulp_port(next); 2956 2957 return (FC_SUCCESS); 2958 } else { 2959 return (FC_FAILURE); 2960 } 2961 } 2962 2963 2964 static void 2965 fctl_dealloc_ulp_port(fc_ulp_ports_t *next) 2966 { 2967 mutex_destroy(&next->port_mutex); 2968 kmem_free(next, sizeof (*next)); 2969 } 2970 2971 2972 static fc_ulp_ports_t * 2973 fctl_get_ulp_port(struct ulp_module *ulp_module, fc_local_port_t *port_handle) 2974 { 2975 fc_ulp_ports_t *next; 2976 2977 ASSERT(RW_LOCK_HELD(&fctl_ulp_lock)); 2978 ASSERT(RW_LOCK_HELD(&fctl_mod_ports_lock)); 2979 2980 for (next = ulp_module->mod_ports; next != NULL; 2981 next = next->port_next) { 2982 if (next->port_handle == port_handle) { 2983 return (next); 2984 } 2985 } 2986 2987 return (NULL); 2988 } 2989 2990 2991 /* 2992 * Pass state change notfications on to registered ULPs. 2993 * 2994 * Can issue wakeups to client callers who might be waiting for completions 2995 * on other threads. 2996 * 2997 * Caution: will silently deallocate any fc_remote_port_t and/or 2998 * fc_remote_node_t structs it finds that are not in use. 2999 */ 3000 void 3001 fctl_ulp_statec_cb(void *arg) 3002 { 3003 uint32_t s_id; 3004 uint32_t new_state; 3005 fc_local_port_t *port; 3006 fc_ulp_ports_t *ulp_port; 3007 fc_ulp_module_t *mod; 3008 fc_port_clist_t *clist = (fc_port_clist_t *)arg; 3009 3010 ASSERT(clist != NULL); 3011 3012 port = clist->clist_port; 3013 3014 mutex_enter(&port->fp_mutex); 3015 s_id = port->fp_port_id.port_id; 3016 mutex_exit(&port->fp_mutex); 3017 3018 switch (clist->clist_state) { 3019 case FC_STATE_ONLINE: 3020 new_state = FC_ULP_STATEC_ONLINE; 3021 break; 3022 3023 case FC_STATE_OFFLINE: 3024 if (clist->clist_len) { 3025 new_state = FC_ULP_STATEC_OFFLINE_TIMEOUT; 3026 } else { 3027 new_state = FC_ULP_STATEC_OFFLINE; 3028 } 3029 break; 3030 3031 default: 3032 new_state = FC_ULP_STATEC_DONT_CARE; 3033 break; 3034 } 3035 3036 #ifdef DEBUG 3037 /* 3038 * sanity check for presence of OLD devices in the hash lists 3039 */ 3040 if (clist->clist_size) { 3041 int count; 3042 fc_remote_port_t *pd; 3043 3044 ASSERT(clist->clist_map != NULL); 3045 for (count = 0; count < clist->clist_len; count++) { 3046 if (clist->clist_map[count].map_state == 3047 PORT_DEVICE_INVALID) { 3048 la_wwn_t pwwn; 3049 fc_portid_t d_id; 3050 3051 pd = clist->clist_map[count].map_pd; 3052 if (pd != NULL) { 3053 mutex_enter(&pd->pd_mutex); 3054 pwwn = pd->pd_port_name; 3055 d_id = pd->pd_port_id; 3056 mutex_exit(&pd->pd_mutex); 3057 3058 pd = fctl_get_remote_port_by_pwwn(port, 3059 &pwwn); 3060 3061 ASSERT(pd != clist->clist_map[count]. 3062 map_pd); 3063 3064 pd = fctl_get_remote_port_by_did(port, 3065 d_id.port_id); 3066 ASSERT(pd != clist->clist_map[count]. 3067 map_pd); 3068 } 3069 } 3070 } 3071 } 3072 #endif 3073 3074 /* 3075 * Check for duplicate map entries 3076 */ 3077 if (clist->clist_size) { 3078 int count; 3079 fc_remote_port_t *pd1, *pd2; 3080 3081 ASSERT(clist->clist_map != NULL); 3082 for (count = 0; count < clist->clist_len-1; count++) { 3083 int count2; 3084 3085 pd1 = clist->clist_map[count].map_pd; 3086 if (pd1 == NULL) { 3087 continue; 3088 } 3089 3090 for (count2 = count+1; 3091 count2 < clist->clist_len; 3092 count2++) { 3093 3094 pd2 = clist->clist_map[count2].map_pd; 3095 if (pd2 == NULL) { 3096 continue; 3097 } 3098 3099 if (pd1 == pd2) { 3100 clist->clist_map[count].map_flags |= 3101 PORT_DEVICE_DUPLICATE_MAP_ENTRY; 3102 break; 3103 } 3104 } 3105 } 3106 } 3107 3108 3109 rw_enter(&fctl_ulp_lock, RW_READER); 3110 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 3111 rw_enter(&fctl_mod_ports_lock, RW_READER); 3112 ulp_port = fctl_get_ulp_port(mod, port); 3113 rw_exit(&fctl_mod_ports_lock); 3114 3115 if (ulp_port == NULL) { 3116 continue; 3117 } 3118 3119 mutex_enter(&ulp_port->port_mutex); 3120 if (FCTL_DISALLOW_CALLBACKS(ulp_port->port_dstate)) { 3121 mutex_exit(&ulp_port->port_mutex); 3122 continue; 3123 } 3124 3125 switch (ulp_port->port_statec) { 3126 case FC_ULP_STATEC_DONT_CARE: 3127 if (ulp_port->port_statec != new_state) { 3128 ulp_port->port_statec = new_state; 3129 } 3130 break; 3131 3132 case FC_ULP_STATEC_ONLINE: 3133 case FC_ULP_STATEC_OFFLINE: 3134 if (ulp_port->port_statec == new_state) { 3135 mutex_exit(&ulp_port->port_mutex); 3136 continue; 3137 } 3138 ulp_port->port_statec = new_state; 3139 break; 3140 3141 case FC_ULP_STATEC_OFFLINE_TIMEOUT: 3142 if (ulp_port->port_statec == new_state || 3143 new_state == FC_ULP_STATEC_OFFLINE) { 3144 mutex_exit(&ulp_port->port_mutex); 3145 continue; 3146 } 3147 ulp_port->port_statec = new_state; 3148 break; 3149 3150 default: 3151 ASSERT(0); 3152 break; 3153 } 3154 3155 mod->mod_info->ulp_statec_callback( 3156 mod->mod_info->ulp_handle, (opaque_t)port, 3157 clist->clist_state, clist->clist_flags, 3158 clist->clist_map, clist->clist_len, s_id); 3159 3160 mutex_exit(&ulp_port->port_mutex); 3161 } 3162 rw_exit(&fctl_ulp_lock); 3163 3164 if (clist->clist_size) { 3165 int count; 3166 fc_remote_node_t *node; 3167 fc_remote_port_t *pd; 3168 3169 ASSERT(clist->clist_map != NULL); 3170 for (count = 0; count < clist->clist_len; count++) { 3171 3172 if ((pd = clist->clist_map[count].map_pd) == NULL) { 3173 continue; 3174 } 3175 3176 mutex_enter(&pd->pd_mutex); 3177 3178 pd->pd_ref_count--; 3179 ASSERT(pd->pd_ref_count >= 0); 3180 3181 if (clist->clist_map[count].map_state != 3182 PORT_DEVICE_INVALID) { 3183 mutex_exit(&pd->pd_mutex); 3184 continue; 3185 } 3186 3187 node = pd->pd_remote_nodep; 3188 pd->pd_aux_flags &= ~PD_GIVEN_TO_ULPS; 3189 3190 mutex_exit(&pd->pd_mutex); 3191 3192 /* 3193 * This fc_remote_port_t is no longer referenced 3194 * by any ULPs. Deallocate it if its pd_ref_count 3195 * has reached zero. 3196 */ 3197 if ((fctl_destroy_remote_port(port, pd) == 0) && 3198 (node != NULL)) { 3199 fctl_destroy_remote_node(node); 3200 } 3201 } 3202 3203 kmem_free(clist->clist_map, 3204 sizeof (*(clist->clist_map)) * clist->clist_size); 3205 } 3206 3207 if (clist->clist_wait) { 3208 mutex_enter(&clist->clist_mutex); 3209 clist->clist_wait = 0; 3210 cv_signal(&clist->clist_cv); 3211 mutex_exit(&clist->clist_mutex); 3212 } else { 3213 kmem_free(clist, sizeof (*clist)); 3214 } 3215 } 3216 3217 3218 /* 3219 * Allocate an fc_remote_node_t struct to represent a remote node for the 3220 * given nwwn. This will also add the nwwn to the global nwwn table. 3221 * 3222 * Returns a pointer to the newly-allocated struct. Returns NULL if 3223 * the kmem_zalloc fails or if the enlist_wwn attempt fails. 3224 */ 3225 fc_remote_node_t * 3226 fctl_create_remote_node(la_wwn_t *nwwn, int sleep) 3227 { 3228 fc_remote_node_t *rnodep; 3229 3230 if ((rnodep = kmem_zalloc(sizeof (*rnodep), sleep)) == NULL) { 3231 return (NULL); 3232 } 3233 3234 mutex_init(&rnodep->fd_mutex, NULL, MUTEX_DRIVER, NULL); 3235 3236 rnodep->fd_node_name = *nwwn; 3237 rnodep->fd_flags = FC_REMOTE_NODE_VALID; 3238 rnodep->fd_numports = 1; 3239 3240 if (fctl_enlist_nwwn_table(rnodep, sleep) != FC_SUCCESS) { 3241 mutex_destroy(&rnodep->fd_mutex); 3242 kmem_free(rnodep, sizeof (*rnodep)); 3243 return (NULL); 3244 } 3245 3246 return (rnodep); 3247 } 3248 3249 /* 3250 * Deconstruct and free the given fc_remote_node_t struct (remote node struct). 3251 * Silently skips the deconstruct/free if there are any fc_remote_port_t 3252 * (remote port device) structs still referenced by the given 3253 * fc_remote_node_t struct. 3254 */ 3255 void 3256 fctl_destroy_remote_node(fc_remote_node_t *rnodep) 3257 { 3258 mutex_enter(&rnodep->fd_mutex); 3259 3260 /* 3261 * Look at the count and linked list of of remote ports 3262 * (fc_remote_port_t structs); bail if these indicate that 3263 * given fc_remote_node_t may be in use. 3264 */ 3265 if (rnodep->fd_numports != 0 || rnodep->fd_portlistp) { 3266 mutex_exit(&rnodep->fd_mutex); 3267 return; 3268 } 3269 3270 mutex_exit(&rnodep->fd_mutex); 3271 3272 mutex_destroy(&rnodep->fd_mutex); 3273 kmem_free(rnodep, sizeof (*rnodep)); 3274 } 3275 3276 3277 /* 3278 * Add the given fc_remote_node_t to the global fctl_nwwn_hash_table[]. This 3279 * uses the nwwn in the fd_node_name.raw_wwn of the given struct. 3280 * This only fails if the kmem_zalloc fails. This does not check for a 3281 * unique or pre-existing nwwn in the fctl_nwwn_hash_table[]. 3282 * This is only called from fctl_create_remote_node(). 3283 */ 3284 int 3285 fctl_enlist_nwwn_table(fc_remote_node_t *rnodep, int sleep) 3286 { 3287 int index; 3288 fctl_nwwn_elem_t *new; 3289 fctl_nwwn_list_t *head; 3290 3291 ASSERT(!MUTEX_HELD(&rnodep->fd_mutex)); 3292 3293 if ((new = kmem_zalloc(sizeof (*new), sleep)) == NULL) { 3294 return (FC_FAILURE); 3295 } 3296 3297 mutex_enter(&fctl_nwwn_hash_mutex); 3298 new->fne_nodep = rnodep; 3299 3300 mutex_enter(&rnodep->fd_mutex); 3301 ASSERT(fctl_is_wwn_zero(&rnodep->fd_node_name) == FC_FAILURE); 3302 index = HASH_FUNC(WWN_HASH_KEY(rnodep->fd_node_name.raw_wwn), 3303 fctl_nwwn_table_size); 3304 mutex_exit(&rnodep->fd_mutex); 3305 3306 head = &fctl_nwwn_hash_table[index]; 3307 3308 /* Link it in at the head of the hash list */ 3309 new->fne_nextp = head->fnl_headp; 3310 head->fnl_headp = new; 3311 3312 mutex_exit(&fctl_nwwn_hash_mutex); 3313 3314 return (FC_SUCCESS); 3315 } 3316 3317 3318 /* 3319 * Remove the given fc_remote_node_t from the global fctl_nwwn_hash_table[]. 3320 * This uses the nwwn in the fd_node_name.raw_wwn of the given struct. 3321 */ 3322 void 3323 fctl_delist_nwwn_table(fc_remote_node_t *rnodep) 3324 { 3325 int index; 3326 fctl_nwwn_list_t *head; 3327 fctl_nwwn_elem_t *elem; 3328 fctl_nwwn_elem_t *prev; 3329 3330 ASSERT(MUTEX_HELD(&fctl_nwwn_hash_mutex)); 3331 ASSERT(MUTEX_HELD(&rnodep->fd_mutex)); 3332 3333 index = HASH_FUNC(WWN_HASH_KEY(rnodep->fd_node_name.raw_wwn), 3334 fctl_nwwn_table_size); 3335 3336 head = &fctl_nwwn_hash_table[index]; 3337 elem = head->fnl_headp; 3338 prev = NULL; 3339 3340 while (elem != NULL) { 3341 if (elem->fne_nodep == rnodep) { 3342 /* 3343 * Found it -- unlink it from the list & decrement 3344 * the count for the hash chain. 3345 */ 3346 if (prev == NULL) { 3347 head->fnl_headp = elem->fne_nextp; 3348 } else { 3349 prev->fne_nextp = elem->fne_nextp; 3350 } 3351 break; 3352 } 3353 prev = elem; 3354 elem = elem->fne_nextp; 3355 } 3356 3357 if (elem != NULL) { 3358 kmem_free(elem, sizeof (*elem)); 3359 } 3360 } 3361 3362 3363 /* 3364 * Returns a reference to an fc_remote_node_t struct for the given node_wwn. 3365 * Looks in the global fctl_nwwn_hash_table[]. Identical to the 3366 * fctl_lock_remote_node_by_nwwn() function, except that this does NOT increment 3367 * the fc_count reference count in the f_device_t before returning. 3368 * 3369 * This function is called by: fctl_create_remote_port_t(). 3370 * 3371 * OLD COMMENT: 3372 * Note: The calling thread needs to make sure it isn't holding any device 3373 * mutex (more so the fc_remote_node_t that could potentially have this wwn). 3374 */ 3375 fc_remote_node_t * 3376 fctl_get_remote_node_by_nwwn(la_wwn_t *node_wwn) 3377 { 3378 int index; 3379 fctl_nwwn_elem_t *elem; 3380 fc_remote_node_t *next; 3381 fc_remote_node_t *rnodep = NULL; 3382 3383 index = HASH_FUNC(WWN_HASH_KEY(node_wwn->raw_wwn), 3384 fctl_nwwn_table_size); 3385 ASSERT(index >= 0 && index < fctl_nwwn_table_size); 3386 3387 mutex_enter(&fctl_nwwn_hash_mutex); 3388 elem = fctl_nwwn_hash_table[index].fnl_headp; 3389 while (elem != NULL) { 3390 next = elem->fne_nodep; 3391 if (next != NULL) { 3392 mutex_enter(&next->fd_mutex); 3393 if (fctl_wwn_cmp(node_wwn, &next->fd_node_name) == 0) { 3394 rnodep = next; 3395 mutex_exit(&next->fd_mutex); 3396 break; 3397 } 3398 mutex_exit(&next->fd_mutex); 3399 } 3400 elem = elem->fne_nextp; 3401 } 3402 mutex_exit(&fctl_nwwn_hash_mutex); 3403 3404 return (rnodep); 3405 } 3406 3407 3408 /* 3409 * Returns a reference to an fc_remote_node_t struct for the given node_wwn. 3410 * Looks in the global fctl_nwwn_hash_table[]. Increments the fd_numports 3411 * reference count in the f_device_t before returning. 3412 * 3413 * This function is only called by fctl_create_remote_port_t(). 3414 */ 3415 fc_remote_node_t * 3416 fctl_lock_remote_node_by_nwwn(la_wwn_t *node_wwn) 3417 { 3418 int index; 3419 fctl_nwwn_elem_t *elem; 3420 fc_remote_node_t *next; 3421 fc_remote_node_t *rnodep = NULL; 3422 3423 index = HASH_FUNC(WWN_HASH_KEY(node_wwn->raw_wwn), 3424 fctl_nwwn_table_size); 3425 ASSERT(index >= 0 && index < fctl_nwwn_table_size); 3426 3427 mutex_enter(&fctl_nwwn_hash_mutex); 3428 elem = fctl_nwwn_hash_table[index].fnl_headp; 3429 while (elem != NULL) { 3430 next = elem->fne_nodep; 3431 if (next != NULL) { 3432 mutex_enter(&next->fd_mutex); 3433 if (fctl_wwn_cmp(node_wwn, &next->fd_node_name) == 0) { 3434 rnodep = next; 3435 rnodep->fd_numports++; 3436 mutex_exit(&next->fd_mutex); 3437 break; 3438 } 3439 mutex_exit(&next->fd_mutex); 3440 } 3441 elem = elem->fne_nextp; 3442 } 3443 mutex_exit(&fctl_nwwn_hash_mutex); 3444 3445 return (rnodep); 3446 } 3447 3448 3449 /* 3450 * Allocate and initialize an fc_remote_port_t struct & returns a pointer to 3451 * the newly allocated struct. Only fails if the kmem_zalloc() fails. 3452 */ 3453 fc_remote_port_t * 3454 fctl_alloc_remote_port(fc_local_port_t *port, la_wwn_t *port_wwn, 3455 uint32_t d_id, uchar_t recepient, int sleep) 3456 { 3457 fc_remote_port_t *pd; 3458 3459 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3460 ASSERT(FC_IS_REAL_DEVICE(d_id)); 3461 3462 if ((pd = kmem_zalloc(sizeof (*pd), sleep)) == NULL) { 3463 return (NULL); 3464 } 3465 fctl_tc_constructor(&pd->pd_logo_tc, FC_LOGO_TOLERANCE_LIMIT, 3466 FC_LOGO_TOLERANCE_TIME_LIMIT); 3467 3468 mutex_init(&pd->pd_mutex, NULL, MUTEX_DRIVER, NULL); 3469 3470 pd->pd_port_id.port_id = d_id; 3471 pd->pd_port_name = *port_wwn; 3472 pd->pd_port = port; 3473 pd->pd_state = PORT_DEVICE_VALID; 3474 pd->pd_type = PORT_DEVICE_NEW; 3475 pd->pd_recepient = recepient; 3476 3477 return (pd); 3478 } 3479 3480 3481 /* 3482 * Deconstruct and free the given fc_remote_port_t struct (unconditionally). 3483 */ 3484 void 3485 fctl_dealloc_remote_port(fc_remote_port_t *pd) 3486 { 3487 ASSERT(!MUTEX_HELD(&pd->pd_mutex)); 3488 3489 fctl_tc_destructor(&pd->pd_logo_tc); 3490 mutex_destroy(&pd->pd_mutex); 3491 kmem_free(pd, sizeof (*pd)); 3492 } 3493 3494 /* 3495 * Add the given fc_remote_port_t onto the linked list of remote port 3496 * devices associated with the given fc_remote_node_t. Does NOT add the 3497 * fc_remote_port_t to the list if already exists on the list. 3498 */ 3499 void 3500 fctl_link_remote_port_to_remote_node(fc_remote_node_t *rnodep, 3501 fc_remote_port_t *pd) 3502 { 3503 fc_remote_port_t *last; 3504 fc_remote_port_t *ports; 3505 3506 mutex_enter(&rnodep->fd_mutex); 3507 3508 last = NULL; 3509 for (ports = rnodep->fd_portlistp; ports != NULL; 3510 ports = ports->pd_port_next) { 3511 if (ports == pd) { 3512 /* 3513 * The given fc_remote_port_t is already on the linked 3514 * list chain for the given remote node, so bail now. 3515 */ 3516 mutex_exit(&rnodep->fd_mutex); 3517 return; 3518 } 3519 last = ports; 3520 } 3521 3522 /* Add the fc_remote_port_t to the tail of the linked list */ 3523 if (last != NULL) { 3524 last->pd_port_next = pd; 3525 } else { 3526 rnodep->fd_portlistp = pd; 3527 } 3528 pd->pd_port_next = NULL; 3529 3530 /* 3531 * Link the fc_remote_port_t back to the associated fc_remote_node_t. 3532 */ 3533 mutex_enter(&pd->pd_mutex); 3534 pd->pd_remote_nodep = rnodep; 3535 mutex_exit(&pd->pd_mutex); 3536 3537 mutex_exit(&rnodep->fd_mutex); 3538 } 3539 3540 3541 /* 3542 * Remove the specified fc_remote_port_t from the linked list of remote ports 3543 * for the given fc_remote_node_t. 3544 * 3545 * Returns a count of the _remaining_ fc_remote_port_t structs on the linked 3546 * list of the fc_remote_node_t. 3547 * 3548 * The fd_numports on the given fc_remote_node_t is decremented, and if 3549 * it hits zero then this function also removes the fc_remote_node_t from the 3550 * global fctl_nwwn_hash_table[]. This appears to be the ONLY WAY that entries 3551 * are removed from the fctl_nwwn_hash_table[]. 3552 */ 3553 int 3554 fctl_unlink_remote_port_from_remote_node(fc_remote_node_t *rnodep, 3555 fc_remote_port_t *pd) 3556 { 3557 int rcount = 0; 3558 fc_remote_port_t *last; 3559 fc_remote_port_t *ports; 3560 3561 ASSERT(!MUTEX_HELD(&rnodep->fd_mutex)); 3562 ASSERT(!MUTEX_HELD(&pd->pd_mutex)); 3563 3564 last = NULL; 3565 3566 mutex_enter(&fctl_nwwn_hash_mutex); 3567 3568 mutex_enter(&rnodep->fd_mutex); 3569 3570 /* 3571 * Go thru the linked list of fc_remote_port_t structs for the given 3572 * fc_remote_node_t; try to find the specified fc_remote_port_t (pd). 3573 */ 3574 ports = rnodep->fd_portlistp; 3575 while (ports != NULL) { 3576 if (ports == pd) { 3577 break; /* Found the requested fc_remote_port_t */ 3578 } 3579 last = ports; 3580 ports = ports->pd_port_next; 3581 } 3582 3583 if (ports) { 3584 rcount = --rnodep->fd_numports; 3585 if (rcount == 0) { 3586 /* Note: this is only ever called from here */ 3587 fctl_delist_nwwn_table(rnodep); 3588 } 3589 if (last) { 3590 last->pd_port_next = pd->pd_port_next; 3591 } else { 3592 rnodep->fd_portlistp = pd->pd_port_next; 3593 } 3594 mutex_enter(&pd->pd_mutex); 3595 pd->pd_remote_nodep = NULL; 3596 mutex_exit(&pd->pd_mutex); 3597 } 3598 3599 pd->pd_port_next = NULL; 3600 3601 mutex_exit(&rnodep->fd_mutex); 3602 mutex_exit(&fctl_nwwn_hash_mutex); 3603 3604 return (rcount); 3605 } 3606 3607 3608 /* 3609 * Add the given fc_remote_port_t struct to the d_id table in the given 3610 * fc_local_port_t struct. Hashes based upon the pd->pd_port_id.port_id in the 3611 * fc_remote_port_t. 3612 * 3613 * No memory allocs are required, so this never fails, but it does use the 3614 * (pd->pd_aux_flags & PD_IN_DID_QUEUE) to keep duplicates off the list. 3615 * (There does not seem to be a way to tell the caller that a duplicate 3616 * exists.) 3617 */ 3618 void 3619 fctl_enlist_did_table(fc_local_port_t *port, fc_remote_port_t *pd) 3620 { 3621 struct d_id_hash *head; 3622 3623 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3624 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 3625 3626 if (pd->pd_aux_flags & PD_IN_DID_QUEUE) { 3627 return; 3628 } 3629 3630 head = &port->fp_did_table[D_ID_HASH_FUNC(pd->pd_port_id.port_id, 3631 did_table_size)]; 3632 3633 #ifdef DEBUG 3634 { 3635 int index; 3636 fc_remote_port_t *tmp_pd; 3637 struct d_id_hash *tmp_head; 3638 3639 /* 3640 * Search down in each bucket for a duplicate pd 3641 * Also search for duplicate D_IDs 3642 * This DEBUG code will force an ASSERT if a duplicate 3643 * is ever found. 3644 */ 3645 for (index = 0; index < did_table_size; index++) { 3646 tmp_head = &port->fp_did_table[index]; 3647 3648 tmp_pd = tmp_head->d_id_head; 3649 while (tmp_pd != NULL) { 3650 ASSERT(tmp_pd != pd); 3651 3652 if (tmp_pd->pd_state != PORT_DEVICE_INVALID && 3653 tmp_pd->pd_type != PORT_DEVICE_OLD) { 3654 ASSERT(tmp_pd->pd_port_id.port_id != 3655 pd->pd_port_id.port_id); 3656 } 3657 3658 tmp_pd = tmp_pd->pd_did_hnext; 3659 } 3660 } 3661 } 3662 3663 bzero(pd->pd_d_stack, sizeof (pd->pd_d_stack)); 3664 pd->pd_d_depth = getpcstack(pd->pd_d_stack, FC_STACK_DEPTH); 3665 #endif 3666 3667 pd->pd_did_hnext = head->d_id_head; 3668 head->d_id_head = pd; 3669 3670 pd->pd_aux_flags |= PD_IN_DID_QUEUE; 3671 head->d_id_count++; 3672 } 3673 3674 3675 /* 3676 * Remove the given fc_remote_port_t struct from the d_id table in the given 3677 * fc_local_port_t struct. Hashes based upon the pd->pd_port_id.port_id in the 3678 * fc_remote_port_t. 3679 * 3680 * Does nothing if the requested fc_remote_port_t was not found. 3681 */ 3682 void 3683 fctl_delist_did_table(fc_local_port_t *port, fc_remote_port_t *pd) 3684 { 3685 uint32_t d_id; 3686 struct d_id_hash *head; 3687 fc_remote_port_t *pd_next; 3688 fc_remote_port_t *last; 3689 3690 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3691 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 3692 3693 d_id = pd->pd_port_id.port_id; 3694 head = &port->fp_did_table[D_ID_HASH_FUNC(d_id, did_table_size)]; 3695 3696 pd_next = head->d_id_head; 3697 last = NULL; 3698 while (pd_next != NULL) { 3699 if (pd == pd_next) { 3700 break; /* Found the given fc_remote_port_t */ 3701 } 3702 last = pd_next; 3703 pd_next = pd_next->pd_did_hnext; 3704 } 3705 3706 if (pd_next) { 3707 /* 3708 * Found the given fc_remote_port_t; now remove it from the 3709 * d_id list. 3710 */ 3711 head->d_id_count--; 3712 if (last == NULL) { 3713 head->d_id_head = pd->pd_did_hnext; 3714 } else { 3715 last->pd_did_hnext = pd->pd_did_hnext; 3716 } 3717 pd->pd_aux_flags &= ~PD_IN_DID_QUEUE; 3718 pd->pd_did_hnext = NULL; 3719 } 3720 } 3721 3722 3723 /* 3724 * Add the given fc_remote_port_t struct to the pwwn table in the given 3725 * fc_local_port_t struct. Hashes based upon the pd->pd_port_name.raw_wwn 3726 * in the fc_remote_port_t. 3727 * 3728 * No memory allocs are required, so this never fails. 3729 */ 3730 void 3731 fctl_enlist_pwwn_table(fc_local_port_t *port, fc_remote_port_t *pd) 3732 { 3733 int index; 3734 struct pwwn_hash *head; 3735 3736 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3737 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 3738 3739 ASSERT(fctl_is_wwn_zero(&pd->pd_port_name) == FC_FAILURE); 3740 3741 index = HASH_FUNC(WWN_HASH_KEY(pd->pd_port_name.raw_wwn), 3742 pwwn_table_size); 3743 3744 head = &port->fp_pwwn_table[index]; 3745 3746 #ifdef DEBUG 3747 { 3748 int index; 3749 fc_remote_port_t *tmp_pd; 3750 struct pwwn_hash *tmp_head; 3751 3752 /* 3753 * Search down in each bucket for a duplicate pd 3754 * Search also for a duplicate WWN 3755 * Throw an ASSERT if any duplicate is found. 3756 */ 3757 for (index = 0; index < pwwn_table_size; index++) { 3758 tmp_head = &port->fp_pwwn_table[index]; 3759 3760 tmp_pd = tmp_head->pwwn_head; 3761 while (tmp_pd != NULL) { 3762 ASSERT(tmp_pd != pd); 3763 3764 if (tmp_pd->pd_state != PORT_DEVICE_INVALID && 3765 tmp_pd->pd_type != PORT_DEVICE_OLD) { 3766 ASSERT(fctl_wwn_cmp( 3767 &tmp_pd->pd_port_name, 3768 &pd->pd_port_name) != 0); 3769 } 3770 3771 tmp_pd = tmp_pd->pd_wwn_hnext; 3772 } 3773 } 3774 } 3775 3776 bzero(pd->pd_w_stack, sizeof (pd->pd_w_stack)); 3777 pd->pd_w_depth = getpcstack(pd->pd_w_stack, FC_STACK_DEPTH); 3778 #endif /* DEBUG */ 3779 3780 pd->pd_wwn_hnext = head->pwwn_head; 3781 head->pwwn_head = pd; 3782 3783 head->pwwn_count++; 3784 /* 3785 * Make sure we tie fp_dev_count to the size of the 3786 * pwwn_table 3787 */ 3788 port->fp_dev_count++; 3789 } 3790 3791 3792 /* 3793 * Remove the given fc_remote_port_t struct from the pwwn table in the given 3794 * fc_local_port_t struct. Hashes based upon the pd->pd_port_name.raw_wwn 3795 * in the fc_remote_port_t. 3796 * 3797 * Does nothing if the requested fc_remote_port_t was not found. 3798 */ 3799 void 3800 fctl_delist_pwwn_table(fc_local_port_t *port, fc_remote_port_t *pd) 3801 { 3802 int index; 3803 la_wwn_t pwwn; 3804 struct pwwn_hash *head; 3805 fc_remote_port_t *pd_next; 3806 fc_remote_port_t *last; 3807 3808 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3809 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 3810 3811 pwwn = pd->pd_port_name; 3812 index = HASH_FUNC(WWN_HASH_KEY(pwwn.raw_wwn), pwwn_table_size); 3813 3814 head = &port->fp_pwwn_table[index]; 3815 3816 last = NULL; 3817 pd_next = head->pwwn_head; 3818 while (pd_next != NULL) { 3819 if (pd_next == pd) { 3820 break; /* Found the given fc_remote_port_t */ 3821 } 3822 last = pd_next; 3823 pd_next = pd_next->pd_wwn_hnext; 3824 } 3825 3826 if (pd_next) { 3827 /* 3828 * Found the given fc_remote_port_t; now remove it from the 3829 * pwwn list. 3830 */ 3831 head->pwwn_count--; 3832 /* 3833 * Make sure we tie fp_dev_count to the size of the 3834 * pwwn_table 3835 */ 3836 port->fp_dev_count--; 3837 if (last == NULL) { 3838 head->pwwn_head = pd->pd_wwn_hnext; 3839 } else { 3840 last->pd_wwn_hnext = pd->pd_wwn_hnext; 3841 } 3842 pd->pd_wwn_hnext = NULL; 3843 } 3844 } 3845 3846 3847 /* 3848 * Looks in the d_id table of the specified fc_local_port_t for the 3849 * fc_remote_port_t that matches the given d_id. Hashes based upon 3850 * the given d_id. 3851 * Returns a pointer to the fc_remote_port_t struct, but does not update any 3852 * reference counts or otherwise indicate that the fc_remote_port_t is in 3853 * use. 3854 */ 3855 fc_remote_port_t * 3856 fctl_get_remote_port_by_did(fc_local_port_t *port, uint32_t d_id) 3857 { 3858 struct d_id_hash *head; 3859 fc_remote_port_t *pd; 3860 3861 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 3862 3863 mutex_enter(&port->fp_mutex); 3864 3865 head = &port->fp_did_table[D_ID_HASH_FUNC(d_id, did_table_size)]; 3866 3867 pd = head->d_id_head; 3868 while (pd != NULL) { 3869 mutex_enter(&pd->pd_mutex); 3870 if (pd->pd_port_id.port_id == d_id) { 3871 /* Match found -- break out of the loop */ 3872 mutex_exit(&pd->pd_mutex); 3873 break; 3874 } 3875 mutex_exit(&pd->pd_mutex); 3876 pd = pd->pd_did_hnext; 3877 } 3878 3879 mutex_exit(&port->fp_mutex); 3880 3881 return (pd); 3882 } 3883 3884 3885 #ifndef __lock_lint /* uncomment when there is a consumer */ 3886 3887 void 3888 fc_ulp_hold_remote_port(opaque_t port_handle) 3889 { 3890 fc_remote_port_t *pd = port_handle; 3891 3892 mutex_enter(&pd->pd_mutex); 3893 pd->pd_ref_count++; 3894 mutex_exit(&pd->pd_mutex); 3895 } 3896 3897 /* 3898 * Looks in the d_id table of the specified fc_local_port_t for the 3899 * fc_remote_port_t that matches the given d_id. Hashes based upon 3900 * the given d_id. Returns a pointer to the fc_remote_port_t struct. 3901 * 3902 * Increments pd_ref_count in the fc_remote_port_t if the 3903 * fc_remote_port_t is found at the given d_id. 3904 * 3905 * The fc_remote_port_t is ignored (treated as non-existent) if either 3906 * its pd_state == PORT_DEVICE_INVALID _OR_ its pd_type == PORT_DEVICE_OLD. 3907 */ 3908 fc_remote_port_t * 3909 fctl_hold_remote_port_by_did(fc_local_port_t *port, uint32_t d_id) 3910 { 3911 struct d_id_hash *head; 3912 fc_remote_port_t *pd; 3913 3914 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 3915 3916 mutex_enter(&port->fp_mutex); 3917 3918 head = &port->fp_did_table[D_ID_HASH_FUNC(d_id, did_table_size)]; 3919 3920 pd = head->d_id_head; 3921 while (pd != NULL) { 3922 mutex_enter(&pd->pd_mutex); 3923 if (pd->pd_port_id.port_id == d_id && pd->pd_state != 3924 PORT_DEVICE_INVALID && pd->pd_type != PORT_DEVICE_OLD) { 3925 ASSERT(pd->pd_ref_count >= 0); 3926 pd->pd_ref_count++; 3927 mutex_exit(&pd->pd_mutex); 3928 break; 3929 } 3930 mutex_exit(&pd->pd_mutex); 3931 pd = pd->pd_did_hnext; 3932 } 3933 3934 mutex_exit(&port->fp_mutex); 3935 3936 return (pd); 3937 } 3938 3939 #endif /* __lock_lint */ 3940 3941 /* 3942 * Looks in the pwwn table of the specified fc_local_port_t for the 3943 * fc_remote_port_t that matches the given pwwn. Hashes based upon the 3944 * given pwwn->raw_wwn. Returns a pointer to the fc_remote_port_t struct, 3945 * but does not update any reference counts or otherwise indicate that 3946 * the fc_remote_port_t is in use. 3947 */ 3948 fc_remote_port_t * 3949 fctl_get_remote_port_by_pwwn(fc_local_port_t *port, la_wwn_t *pwwn) 3950 { 3951 int index; 3952 struct pwwn_hash *head; 3953 fc_remote_port_t *pd; 3954 3955 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 3956 3957 mutex_enter(&port->fp_mutex); 3958 3959 index = HASH_FUNC(WWN_HASH_KEY(pwwn->raw_wwn), pwwn_table_size); 3960 head = &port->fp_pwwn_table[index]; 3961 3962 pd = head->pwwn_head; 3963 while (pd != NULL) { 3964 mutex_enter(&pd->pd_mutex); 3965 if (fctl_wwn_cmp(&pd->pd_port_name, pwwn) == 0) { 3966 mutex_exit(&pd->pd_mutex); 3967 break; 3968 } 3969 mutex_exit(&pd->pd_mutex); 3970 pd = pd->pd_wwn_hnext; 3971 } 3972 3973 mutex_exit(&port->fp_mutex); 3974 3975 return (pd); 3976 } 3977 3978 3979 /* 3980 * Basically the same as fctl_get_remote_port_by_pwwn(), but requires that 3981 * the caller already hold the fp_mutex in the fc_local_port_t struct. 3982 */ 3983 fc_remote_port_t * 3984 fctl_get_remote_port_by_pwwn_mutex_held(fc_local_port_t *port, la_wwn_t *pwwn) 3985 { 3986 int index; 3987 struct pwwn_hash *head; 3988 fc_remote_port_t *pd; 3989 3990 ASSERT(MUTEX_HELD(&port->fp_mutex)); 3991 3992 index = HASH_FUNC(WWN_HASH_KEY(pwwn->raw_wwn), pwwn_table_size); 3993 head = &port->fp_pwwn_table[index]; 3994 3995 pd = head->pwwn_head; 3996 while (pd != NULL) { 3997 mutex_enter(&pd->pd_mutex); 3998 if (fctl_wwn_cmp(&pd->pd_port_name, pwwn) == 0) { 3999 mutex_exit(&pd->pd_mutex); 4000 break; 4001 } 4002 mutex_exit(&pd->pd_mutex); 4003 pd = pd->pd_wwn_hnext; 4004 } 4005 4006 return (pd); 4007 } 4008 4009 4010 /* 4011 * Looks in the pwwn table of the specified fc_local_port_t for the 4012 * fc_remote_port_t that matches the given d_id. Hashes based upon the 4013 * given pwwn->raw_wwn. Returns a pointer to the fc_remote_port_t struct. 4014 * 4015 * Increments pd_ref_count in the fc_remote_port_t if the 4016 * fc_remote_port_t is found at the given pwwn. 4017 * 4018 * The fc_remote_port_t is ignored (treated as non-existent) if either 4019 * its pd_state == PORT_DEVICE_INVALID _OR_ its pd_type == PORT_DEVICE_OLD. 4020 */ 4021 fc_remote_port_t * 4022 fctl_hold_remote_port_by_pwwn(fc_local_port_t *port, la_wwn_t *pwwn) 4023 { 4024 int index; 4025 struct pwwn_hash *head; 4026 fc_remote_port_t *pd; 4027 4028 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 4029 4030 mutex_enter(&port->fp_mutex); 4031 4032 index = HASH_FUNC(WWN_HASH_KEY(pwwn->raw_wwn), pwwn_table_size); 4033 head = &port->fp_pwwn_table[index]; 4034 4035 pd = head->pwwn_head; 4036 while (pd != NULL) { 4037 mutex_enter(&pd->pd_mutex); 4038 if (fctl_wwn_cmp(&pd->pd_port_name, pwwn) == 0 && 4039 pd->pd_state != PORT_DEVICE_INVALID && 4040 pd->pd_type != PORT_DEVICE_OLD) { 4041 ASSERT(pd->pd_ref_count >= 0); 4042 pd->pd_ref_count++; 4043 mutex_exit(&pd->pd_mutex); 4044 break; 4045 } 4046 mutex_exit(&pd->pd_mutex); 4047 pd = pd->pd_wwn_hnext; 4048 } 4049 4050 mutex_exit(&port->fp_mutex); 4051 4052 return (pd); 4053 } 4054 4055 4056 /* 4057 * Unconditionally decrement pd_ref_count in the given fc_remote_port_t 4058 * struct. 4059 * 4060 * If pd_ref_count reaches zero, then this function will see if the 4061 * fc_remote_port_t has been marked for deallocation. If so (and also if there 4062 * are no other potential operations in progress, as indicated by the 4063 * PD_ELS_IN_PROGRESS & PD_ELS_MARK settings in the pd_flags), then 4064 * fctl_destroy_remote_port_t() is called to deconstruct/free the given 4065 * fc_remote_port_t (which will also remove it from the d_id and pwwn tables 4066 * on the associated fc_local_port_t). If the associated fc_remote_node_t is no 4067 * longer in use, then it too is deconstructed/freed. 4068 */ 4069 void 4070 fctl_release_remote_port(fc_remote_port_t *pd) 4071 { 4072 int remove = 0; 4073 fc_remote_node_t *node; 4074 fc_local_port_t *port; 4075 4076 mutex_enter(&pd->pd_mutex); 4077 port = pd->pd_port; 4078 4079 ASSERT(pd->pd_ref_count > 0); 4080 pd->pd_ref_count--; 4081 if (pd->pd_ref_count == 0 && 4082 (pd->pd_aux_flags & PD_NEEDS_REMOVAL) && 4083 (pd->pd_flags != PD_ELS_IN_PROGRESS) && 4084 (pd->pd_flags != PD_ELS_MARK)) { 4085 remove = 1; 4086 pd->pd_aux_flags &= ~PD_NEEDS_REMOVAL; 4087 } 4088 node = pd->pd_remote_nodep; 4089 ASSERT(node != NULL); 4090 4091 mutex_exit(&pd->pd_mutex); 4092 4093 if (remove) { 4094 /* 4095 * The fc_remote_port_t struct has to go away now, so call the 4096 * cleanup function to get it off the various lists and remove 4097 * references to it in any other associated structs. 4098 */ 4099 if (fctl_destroy_remote_port(port, pd) == 0) { 4100 /* 4101 * No more fc_remote_port_t references found in the 4102 * associated fc_remote_node_t, so deallocate the 4103 * fc_remote_node_t (if it even exists). 4104 */ 4105 if (node) { 4106 fctl_destroy_remote_node(node); 4107 } 4108 } 4109 } 4110 } 4111 4112 4113 void 4114 fctl_fillout_map(fc_local_port_t *port, fc_portmap_t **map, uint32_t *len, 4115 int whole_map, int justcopy, int orphan) 4116 { 4117 int index; 4118 int listlen; 4119 int full_list; 4120 int initiator; 4121 uint32_t topology; 4122 struct pwwn_hash *head; 4123 fc_remote_port_t *pd; 4124 fc_remote_port_t *old_pd; 4125 fc_remote_port_t *last_pd; 4126 fc_portmap_t *listptr; 4127 4128 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 4129 4130 mutex_enter(&port->fp_mutex); 4131 4132 topology = port->fp_topology; 4133 4134 if (orphan) { 4135 ASSERT(!FC_IS_TOP_SWITCH(topology)); 4136 } 4137 4138 for (full_list = listlen = index = 0; 4139 index < pwwn_table_size; index++) { 4140 head = &port->fp_pwwn_table[index]; 4141 pd = head->pwwn_head; 4142 while (pd != NULL) { 4143 full_list++; 4144 mutex_enter(&pd->pd_mutex); 4145 if (pd->pd_type != PORT_DEVICE_NOCHANGE) { 4146 listlen++; 4147 } 4148 mutex_exit(&pd->pd_mutex); 4149 pd = pd->pd_wwn_hnext; 4150 } 4151 } 4152 4153 if (whole_map == 0) { 4154 if (listlen == 0 && *len == 0) { 4155 *map = NULL; 4156 *len = listlen; 4157 mutex_exit(&port->fp_mutex); 4158 return; 4159 } 4160 } else { 4161 if (full_list == 0 && *len == 0) { 4162 *map = NULL; 4163 *len = full_list; 4164 mutex_exit(&port->fp_mutex); 4165 return; 4166 } 4167 } 4168 4169 if (*len == 0) { 4170 ASSERT(*map == NULL); 4171 if (whole_map == 0) { 4172 listptr = *map = kmem_zalloc( 4173 sizeof (*listptr) * listlen, KM_SLEEP); 4174 *len = listlen; 4175 } else { 4176 listptr = *map = kmem_zalloc( 4177 sizeof (*listptr) * full_list, KM_SLEEP); 4178 *len = full_list; 4179 } 4180 } else { 4181 /* 4182 * By design this routine mandates the callers to 4183 * ask for a whole map when they specify the length 4184 * and the listptr. 4185 */ 4186 ASSERT(whole_map == 1); 4187 if (*len < full_list) { 4188 *len = full_list; 4189 mutex_exit(&port->fp_mutex); 4190 return; 4191 } 4192 listptr = *map; 4193 *len = full_list; 4194 } 4195 4196 for (index = 0; index < pwwn_table_size; index++) { 4197 head = &port->fp_pwwn_table[index]; 4198 last_pd = NULL; 4199 pd = head->pwwn_head; 4200 while (pd != NULL) { 4201 mutex_enter(&pd->pd_mutex); 4202 if ((whole_map == 0 && 4203 pd->pd_type == PORT_DEVICE_NOCHANGE) || 4204 pd->pd_state == PORT_DEVICE_INVALID) { 4205 mutex_exit(&pd->pd_mutex); 4206 last_pd = pd; 4207 pd = pd->pd_wwn_hnext; 4208 continue; 4209 } 4210 mutex_exit(&pd->pd_mutex); 4211 4212 fctl_copy_portmap(listptr, pd); 4213 4214 if (justcopy) { 4215 last_pd = pd; 4216 pd = pd->pd_wwn_hnext; 4217 listptr++; 4218 continue; 4219 } 4220 4221 mutex_enter(&pd->pd_mutex); 4222 ASSERT(pd->pd_state != PORT_DEVICE_INVALID); 4223 if (pd->pd_type == PORT_DEVICE_OLD) { 4224 listptr->map_pd = pd; 4225 listptr->map_state = pd->pd_state = 4226 PORT_DEVICE_INVALID; 4227 /* 4228 * Remove this from the PWWN hash table. 4229 */ 4230 old_pd = pd; 4231 pd = old_pd->pd_wwn_hnext; 4232 4233 if (last_pd == NULL) { 4234 ASSERT(old_pd == head->pwwn_head); 4235 4236 head->pwwn_head = pd; 4237 } else { 4238 last_pd->pd_wwn_hnext = pd; 4239 } 4240 head->pwwn_count--; 4241 /* 4242 * Make sure we tie fp_dev_count to the size 4243 * of the pwwn_table 4244 */ 4245 port->fp_dev_count--; 4246 old_pd->pd_wwn_hnext = NULL; 4247 4248 if (port->fp_topology == FC_TOP_PRIVATE_LOOP && 4249 port->fp_statec_busy && !orphan) { 4250 fctl_check_alpa_list(port, old_pd); 4251 } 4252 4253 /* 4254 * Remove if the port device has stealthily 4255 * present in the D_ID hash table 4256 */ 4257 fctl_delist_did_table(port, old_pd); 4258 4259 ASSERT(old_pd->pd_remote_nodep != NULL); 4260 4261 initiator = (old_pd->pd_recepient == 4262 PD_PLOGI_INITIATOR) ? 1 : 0; 4263 4264 mutex_exit(&old_pd->pd_mutex); 4265 mutex_exit(&port->fp_mutex); 4266 4267 if (orphan) { 4268 fctl_print_if_not_orphan(port, old_pd); 4269 4270 (void) fctl_add_orphan(port, old_pd, 4271 KM_NOSLEEP); 4272 } 4273 4274 if (FC_IS_TOP_SWITCH(topology) && initiator) { 4275 (void) fctl_add_orphan(port, old_pd, 4276 KM_NOSLEEP); 4277 } 4278 mutex_enter(&port->fp_mutex); 4279 } else { 4280 listptr->map_pd = pd; 4281 pd->pd_type = PORT_DEVICE_NOCHANGE; 4282 mutex_exit(&pd->pd_mutex); 4283 last_pd = pd; 4284 pd = pd->pd_wwn_hnext; 4285 } 4286 listptr++; 4287 } 4288 } 4289 mutex_exit(&port->fp_mutex); 4290 } 4291 4292 4293 job_request_t * 4294 fctl_alloc_job(int job_code, int job_flags, void (*comp) (opaque_t, uchar_t), 4295 opaque_t arg, int sleep) 4296 { 4297 job_request_t *job; 4298 4299 job = (job_request_t *)kmem_cache_alloc(fctl_job_cache, sleep); 4300 if (job != NULL) { 4301 job->job_result = FC_SUCCESS; 4302 job->job_code = job_code; 4303 job->job_flags = job_flags; 4304 job->job_cb_arg = arg; 4305 job->job_comp = comp; 4306 job->job_private = NULL; 4307 job->job_ulp_pkts = NULL; 4308 job->job_ulp_listlen = 0; 4309 #ifndef __lock_lint 4310 job->job_counter = 0; 4311 job->job_next = NULL; 4312 #endif /* __lock_lint */ 4313 } 4314 4315 return (job); 4316 } 4317 4318 4319 void 4320 fctl_dealloc_job(job_request_t *job) 4321 { 4322 kmem_cache_free(fctl_job_cache, (void *)job); 4323 } 4324 4325 4326 void 4327 fctl_enque_job(fc_local_port_t *port, job_request_t *job) 4328 { 4329 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 4330 4331 mutex_enter(&port->fp_mutex); 4332 4333 if (port->fp_job_tail == NULL) { 4334 ASSERT(port->fp_job_head == NULL); 4335 port->fp_job_head = port->fp_job_tail = job; 4336 } else { 4337 port->fp_job_tail->job_next = job; 4338 port->fp_job_tail = job; 4339 } 4340 job->job_next = NULL; 4341 4342 cv_signal(&port->fp_cv); 4343 mutex_exit(&port->fp_mutex); 4344 } 4345 4346 4347 job_request_t * 4348 fctl_deque_job(fc_local_port_t *port) 4349 { 4350 job_request_t *job; 4351 4352 ASSERT(MUTEX_HELD(&port->fp_mutex)); 4353 4354 if (port->fp_job_head == NULL) { 4355 ASSERT(port->fp_job_tail == NULL); 4356 job = NULL; 4357 } else { 4358 job = port->fp_job_head; 4359 if (job->job_next == NULL) { 4360 ASSERT(job == port->fp_job_tail); 4361 port->fp_job_tail = NULL; 4362 } 4363 port->fp_job_head = job->job_next; 4364 } 4365 4366 return (job); 4367 } 4368 4369 4370 void 4371 fctl_priority_enque_job(fc_local_port_t *port, job_request_t *job) 4372 { 4373 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 4374 4375 mutex_enter(&port->fp_mutex); 4376 if (port->fp_job_tail == NULL) { 4377 ASSERT(port->fp_job_head == NULL); 4378 port->fp_job_head = port->fp_job_tail = job; 4379 job->job_next = NULL; 4380 } else { 4381 job->job_next = port->fp_job_head; 4382 port->fp_job_head = job; 4383 } 4384 cv_signal(&port->fp_cv); 4385 mutex_exit(&port->fp_mutex); 4386 } 4387 4388 4389 void 4390 fctl_jobwait(job_request_t *job) 4391 { 4392 ASSERT(!(job->job_flags & JOB_TYPE_FCTL_ASYNC)); 4393 sema_p(&job->job_fctl_sema); 4394 ASSERT(!MUTEX_HELD(&job->job_mutex)); 4395 } 4396 4397 4398 void 4399 fctl_jobdone(job_request_t *job) 4400 { 4401 if (job->job_flags & JOB_TYPE_FCTL_ASYNC) { 4402 if (job->job_comp) { 4403 job->job_comp(job->job_cb_arg, job->job_result); 4404 } 4405 fctl_dealloc_job(job); 4406 } else { 4407 sema_v(&job->job_fctl_sema); 4408 } 4409 } 4410 4411 4412 /* 4413 * Compare two WWNs. 4414 * The NAA can't be omitted for comparison. 4415 * 4416 * Return Values: 4417 * if src == dst return 0 4418 * if src > dst return 1 4419 * if src < dst return -1 4420 */ 4421 int 4422 fctl_wwn_cmp(la_wwn_t *src, la_wwn_t *dst) 4423 { 4424 uint8_t *l, *r; 4425 int i; 4426 uint64_t wl, wr; 4427 4428 l = (uint8_t *)src; 4429 r = (uint8_t *)dst; 4430 4431 for (i = 0, wl = 0; i < 8; i++) { 4432 wl <<= 8; 4433 wl |= l[i]; 4434 } 4435 for (i = 0, wr = 0; i < 8; i++) { 4436 wr <<= 8; 4437 wr |= r[i]; 4438 } 4439 4440 if (wl > wr) { 4441 return (1); 4442 } else if (wl == wr) { 4443 return (0); 4444 } else { 4445 return (-1); 4446 } 4447 } 4448 4449 4450 /* 4451 * ASCII to Integer goodie with support for base 16, 10, 2 and 8 4452 */ 4453 int 4454 fctl_atoi(char *s, int base) 4455 { 4456 int val; 4457 int ch; 4458 4459 for (val = 0; *s != '\0'; s++) { 4460 switch (base) { 4461 case 16: 4462 if (*s >= '0' && *s <= '9') { 4463 ch = *s - '0'; 4464 } else if (*s >= 'a' && *s <= 'f') { 4465 ch = *s - 'a' + 10; 4466 } else if (*s >= 'A' && *s <= 'F') { 4467 ch = *s - 'A' + 10; 4468 } else { 4469 return (-1); 4470 } 4471 break; 4472 4473 case 10: 4474 if (*s < '0' || *s > '9') { 4475 return (-1); 4476 } 4477 ch = *s - '0'; 4478 break; 4479 4480 case 2: 4481 if (*s < '0' || *s > '1') { 4482 return (-1); 4483 } 4484 ch = *s - '0'; 4485 break; 4486 4487 case 8: 4488 if (*s < '0' || *s > '7') { 4489 return (-1); 4490 } 4491 ch = *s - '0'; 4492 break; 4493 4494 default: 4495 return (-1); 4496 } 4497 val = (val * base) + ch; 4498 } 4499 return (val); 4500 } 4501 4502 4503 /* 4504 * Create the fc_remote_port_t struct for the given port_wwn and d_id. 4505 * 4506 * If the struct already exists (and is "valid"), then use it. Before using 4507 * it, the code below also checks: (a) if the d_id has changed, and (b) if 4508 * the device is maked as PORT_DEVICE_OLD. 4509 * 4510 * If no fc_remote_node_t struct exists for the given node_wwn, then that 4511 * struct is also created (and linked with the fc_remote_port_t). 4512 * 4513 * The given fc_local_port_t struct is updated with the info on the new 4514 * struct(s). The d_id and pwwn hash tables in the port_wwn are updated. 4515 * The global node_hash_table[] is updated (if necessary). 4516 */ 4517 fc_remote_port_t * 4518 fctl_create_remote_port(fc_local_port_t *port, la_wwn_t *node_wwn, 4519 la_wwn_t *port_wwn, uint32_t d_id, uchar_t recepient, int sleep) 4520 { 4521 int invalid = 0; 4522 fc_remote_node_t *rnodep; 4523 fc_remote_port_t *pd; 4524 4525 rnodep = fctl_get_remote_node_by_nwwn(node_wwn); 4526 if (rnodep) { 4527 /* 4528 * We found an fc_remote_node_t for the remote node -- see if 4529 * anyone has marked it as going away or gone. 4530 */ 4531 mutex_enter(&rnodep->fd_mutex); 4532 invalid = (rnodep->fd_flags == FC_REMOTE_NODE_INVALID) ? 1 : 0; 4533 mutex_exit(&rnodep->fd_mutex); 4534 } 4535 if (rnodep == NULL || invalid) { 4536 /* 4537 * No valid remote node struct found -- create it. 4538 * Note: this is the only place that this func is called. 4539 */ 4540 rnodep = fctl_create_remote_node(node_wwn, sleep); 4541 if (rnodep == NULL) { 4542 return (NULL); 4543 } 4544 } 4545 4546 mutex_enter(&port->fp_mutex); 4547 4548 /* 4549 * See if there already is an fc_remote_port_t struct in existence 4550 * on the specified fc_local_port_t for the given pwwn. If so, then 4551 * grab a reference to it. The 'held' here just means that fp_mutex 4552 * is held by the caller -- no reference counts are updated. 4553 */ 4554 pd = fctl_get_remote_port_by_pwwn_mutex_held(port, port_wwn); 4555 if (pd) { 4556 /* 4557 * An fc_remote_port_t struct was found -- see if anyone has 4558 * marked it as "invalid", which means that it is in the 4559 * process of going away & we don't want to use it. 4560 */ 4561 mutex_enter(&pd->pd_mutex); 4562 invalid = (pd->pd_state == PORT_DEVICE_INVALID) ? 1 : 0; 4563 mutex_exit(&pd->pd_mutex); 4564 } 4565 4566 if (pd == NULL || invalid) { 4567 /* 4568 * No fc_remote_port_t was found (or the existing one is 4569 * marked as "invalid".) Allocate a new one and use that. 4570 * This call will also update the d_id and pwwn hash tables 4571 * in the given fc_local_port_t struct with the newly allocated 4572 * fc_remote_port_t. 4573 */ 4574 if ((pd = fctl_alloc_remote_port(port, port_wwn, d_id, 4575 recepient, sleep)) == NULL) { 4576 /* Just give up if the allocation fails. */ 4577 mutex_exit(&port->fp_mutex); 4578 fctl_destroy_remote_node(rnodep); 4579 return (pd); 4580 } 4581 4582 /* 4583 * Add the new fc_remote_port_t struct to the d_id and pwwn 4584 * hash tables on the associated fc_local_port_t struct. 4585 */ 4586 mutex_enter(&pd->pd_mutex); 4587 pd->pd_remote_nodep = rnodep; 4588 fctl_enlist_did_table(port, pd); 4589 fctl_enlist_pwwn_table(port, pd); 4590 mutex_exit(&pd->pd_mutex); 4591 mutex_exit(&port->fp_mutex); 4592 4593 /* 4594 * Retrieve a pointer to the fc_remote_node_t (i.e., remote 4595 * node) specified by the given node_wwn. This looks in the 4596 * global fctl_nwwn_hash_table[]. The fd_numports reference 4597 * count in the fc_remote_node_t struct is incremented. 4598 */ 4599 rnodep = fctl_lock_remote_node_by_nwwn(node_wwn); 4600 4601 } else { 4602 /* 4603 * An existing and valid fc_remote_port_t struct already 4604 * exists on the fc_local_port_t for the given pwwn. 4605 */ 4606 4607 mutex_enter(&pd->pd_mutex); 4608 ASSERT(pd->pd_remote_nodep != NULL); 4609 4610 if (pd->pd_port_id.port_id != d_id) { 4611 /* 4612 * A very unlikely occurance in a well 4613 * behaved environment. 4614 */ 4615 4616 /* 4617 * The existing fc_remote_port_t has a different 4618 * d_id than what we were given. This code will 4619 * update the existing one with the one that was 4620 * just given. 4621 */ 4622 char string[(FCTL_WWN_SIZE(port_wwn) << 1) + 1]; 4623 uint32_t old_id; 4624 4625 fc_wwn_to_str(port_wwn, string); 4626 4627 old_id = pd->pd_port_id.port_id; 4628 4629 fctl_delist_did_table(port, pd); 4630 4631 cmn_err(CE_NOTE, "!fctl(%d): D_ID of a device" 4632 " with PWWN %s changed. New D_ID = %x," 4633 " OLD D_ID = %x", port->fp_instance, string, 4634 d_id, old_id); 4635 4636 pd->pd_port_id.port_id = d_id; 4637 4638 /* 4639 * Looks like we have to presume here that the 4640 * remote port could be something entirely different 4641 * from what was previously existing & valid at this 4642 * pwwn. 4643 */ 4644 pd->pd_type = PORT_DEVICE_CHANGED; 4645 4646 /* Record (update) the new d_id for the remote port */ 4647 fctl_enlist_did_table(port, pd); 4648 4649 } else if (pd->pd_type == PORT_DEVICE_OLD) { 4650 /* 4651 * OK at least the old & new d_id's match. So for 4652 * PORT_DEVICE_OLD, this assumes that the remote 4653 * port had disappeared but now has come back. 4654 * Update the pd_type and pd_state to put the 4655 * remote port back into service. 4656 */ 4657 pd->pd_type = PORT_DEVICE_NOCHANGE; 4658 pd->pd_state = PORT_DEVICE_VALID; 4659 4660 fctl_enlist_did_table(port, pd); 4661 4662 } else { 4663 /* 4664 * OK the old & new d_id's match, and the remote 4665 * port struct is not marked as PORT_DEVICE_OLD, so 4666 * presume that it's still the same device and is 4667 * still in good shape. Also this presumes that we 4668 * do not need to update d_id or pwwn hash tables. 4669 */ 4670 /* sanitize device values */ 4671 pd->pd_type = PORT_DEVICE_NOCHANGE; 4672 pd->pd_state = PORT_DEVICE_VALID; 4673 } 4674 4675 mutex_exit(&pd->pd_mutex); 4676 mutex_exit(&port->fp_mutex); 4677 4678 if (rnodep != pd->pd_remote_nodep) { 4679 if ((rnodep != NULL) && 4680 (fctl_wwn_cmp(&pd->pd_remote_nodep->fd_node_name, 4681 node_wwn) != 0)) { 4682 /* 4683 * Rut-roh, there is an fc_remote_node_t remote 4684 * node struct for the given node_wwn, but the 4685 * fc_remote_port_t remote port struct doesn't 4686 * know about it. This just prints a warning 4687 * message & fails the fc_remote_port_t 4688 * allocation (possible leak here?). 4689 */ 4690 char ww1_name[17]; 4691 char ww2_name[17]; 4692 4693 fc_wwn_to_str( 4694 &pd->pd_remote_nodep->fd_node_name, 4695 ww1_name); 4696 fc_wwn_to_str(node_wwn, ww2_name); 4697 4698 cmn_err(CE_WARN, "fctl(%d) NWWN Mismatch: " 4699 "Expected %s Got %s", port->fp_instance, 4700 ww1_name, ww2_name); 4701 } 4702 4703 return (NULL); 4704 } 4705 } 4706 4707 /* 4708 * Add the fc_remote_port_t onto the linked list of remote port 4709 * devices associated with the given fc_remote_node_t (remote node). 4710 */ 4711 fctl_link_remote_port_to_remote_node(rnodep, pd); 4712 4713 return (pd); 4714 } 4715 4716 4717 /* 4718 * Disassociate the given fc_local_port_t and fc_remote_port_t structs. Removes 4719 * the fc_remote_port_t from the associated fc_remote_node_t. Also removes any 4720 * references to the fc_remote_port_t from the d_id and pwwn tables in the 4721 * given fc_local_port_t. Deallocates the given fc_remote_port_t. 4722 * 4723 * Returns a count of the number of remaining fc_remote_port_t structs 4724 * associated with the fc_remote_node_t struct. 4725 * 4726 * If pd_ref_count in the given fc_remote_port_t is nonzero, then this 4727 * function just sets the pd->pd_aux_flags |= PD_NEEDS_REMOVAL and the 4728 * pd->pd_type = PORT_DEVICE_OLD and lets some other function(s) worry about 4729 * the cleanup. The function then also returns '1' 4730 * instead of the actual number of remaining fc_remote_port_t structs 4731 * 4732 * If there are no more remote ports on the remote node, return 0. 4733 * Otherwise, return non-zero. 4734 */ 4735 int 4736 fctl_destroy_remote_port(fc_local_port_t *port, fc_remote_port_t *pd) 4737 { 4738 fc_remote_node_t *rnodep; 4739 int rcount = 0; 4740 4741 mutex_enter(&pd->pd_mutex); 4742 4743 /* 4744 * If pd_ref_count > 0, we can't pull the rug out from any 4745 * current users of this fc_remote_port_t. We'll mark it as old 4746 * and in need of removal. The same goes for any fc_remote_port_t 4747 * that has a reference handle(s) in a ULP(s) but for which the ULP(s) 4748 * have not yet been notified that the handle is no longer valid 4749 * (i.e., PD_GIVEN_TO_ULPS is set). 4750 */ 4751 if ((pd->pd_ref_count > 0) || 4752 (pd->pd_aux_flags & PD_GIVEN_TO_ULPS)) { 4753 pd->pd_aux_flags |= PD_NEEDS_REMOVAL; 4754 pd->pd_type = PORT_DEVICE_OLD; 4755 mutex_exit(&pd->pd_mutex); 4756 return (1); 4757 } 4758 4759 pd->pd_type = PORT_DEVICE_OLD; 4760 4761 rnodep = pd->pd_remote_nodep; 4762 4763 mutex_exit(&pd->pd_mutex); 4764 4765 if (rnodep != NULL) { 4766 /* 4767 * Remove the fc_remote_port_t from the linked list of remote 4768 * ports for the given fc_remote_node_t. This is only called 4769 * here and in fctl_destroy_all_remote_ports(). 4770 */ 4771 rcount = fctl_unlink_remote_port_from_remote_node(rnodep, pd); 4772 } 4773 4774 mutex_enter(&port->fp_mutex); 4775 mutex_enter(&pd->pd_mutex); 4776 4777 fctl_delist_did_table(port, pd); 4778 fctl_delist_pwwn_table(port, pd); 4779 4780 mutex_exit(&pd->pd_mutex); 4781 4782 /* 4783 * Deconstruct & free the fc_remote_port_t. This is only called 4784 * here and in fctl_destroy_all_remote_ports(). 4785 */ 4786 fctl_dealloc_remote_port(pd); 4787 4788 mutex_exit(&port->fp_mutex); 4789 4790 return (rcount); 4791 } 4792 4793 4794 /* 4795 * This goes thru the d_id table on the given fc_local_port_t. 4796 * For each fc_remote_port_t found, this will: 4797 * 4798 * - Remove the fc_remote_port_t from the linked list of remote ports for 4799 * the associated fc_remote_node_t. If the linked list goes empty, then this 4800 * tries to deconstruct & free the fc_remote_node_t (that also removes the 4801 * fc_remote_node_t from the global fctl_nwwn_hash_table[]). 4802 * 4803 * - Remove the fc_remote_port_t from the pwwn list on the given 4804 * fc_local_port_t. 4805 * 4806 * - Deconstruct and free the fc_remote_port_t. 4807 * 4808 * - Removes the link to the fc_remote_port_t in the d_id table. Note, this 4809 * does not appear to correctle decrement the d_id_count tho. 4810 */ 4811 void 4812 fctl_destroy_all_remote_ports(fc_local_port_t *port) 4813 { 4814 int index; 4815 fc_remote_port_t *pd; 4816 fc_remote_node_t *rnodep; 4817 struct d_id_hash *head; 4818 4819 mutex_enter(&port->fp_mutex); 4820 4821 for (index = 0; index < did_table_size; index++) { 4822 4823 head = &port->fp_did_table[index]; 4824 4825 while (head->d_id_head != NULL) { 4826 pd = head->d_id_head; 4827 4828 /* 4829 * See if this remote port (fc_remote_port_t) has a 4830 * reference to a remote node (fc_remote_node_t) in its 4831 * pd->pd_remote_nodep pointer. 4832 */ 4833 mutex_enter(&pd->pd_mutex); 4834 rnodep = pd->pd_remote_nodep; 4835 mutex_exit(&pd->pd_mutex); 4836 4837 if (rnodep != NULL) { 4838 /* 4839 * An fc_remote_node_t reference exists. Remove 4840 * the fc_remote_port_t from the linked list of 4841 * remote ports for fc_remote_node_t. 4842 */ 4843 if (fctl_unlink_remote_port_from_remote_node( 4844 rnodep, pd) == 0) { 4845 /* 4846 * The fd_numports reference count 4847 * in the fc_remote_node_t has come 4848 * back as zero, so we can free the 4849 * fc_remote_node_t. This also means 4850 * that the fc_remote_node_t was 4851 * removed from the 4852 * fctl_nwwn_hash_table[]. 4853 * 4854 * This will silently skip the 4855 * kmem_free() if either the 4856 * fd_numports is nonzero or 4857 * the fd_port is not NULL in 4858 * the fc_remote_node_t. 4859 */ 4860 fctl_destroy_remote_node(rnodep); 4861 } 4862 } 4863 4864 /* 4865 * Clean up the entry in the fc_local_port_t's pwwn 4866 * table for the given fc_remote_port_t (i.e., the pd). 4867 */ 4868 mutex_enter(&pd->pd_mutex); 4869 fctl_delist_pwwn_table(port, pd); 4870 pd->pd_aux_flags &= ~PD_IN_DID_QUEUE; 4871 mutex_exit(&pd->pd_mutex); 4872 4873 /* 4874 * Remove the current entry from the d_id list. 4875 */ 4876 head->d_id_head = pd->pd_did_hnext; 4877 4878 /* 4879 * Deconstruct & free the fc_remote_port_t (pd) 4880 * Note: this is only called here and in 4881 * fctl_destroy_remote_port_t(). 4882 */ 4883 fctl_dealloc_remote_port(pd); 4884 } 4885 } 4886 4887 mutex_exit(&port->fp_mutex); 4888 } 4889 4890 4891 int 4892 fctl_is_wwn_zero(la_wwn_t *wwn) 4893 { 4894 int count; 4895 4896 for (count = 0; count < sizeof (la_wwn_t); count++) { 4897 if (wwn->raw_wwn[count] != 0) { 4898 return (FC_FAILURE); 4899 } 4900 } 4901 4902 return (FC_SUCCESS); 4903 } 4904 4905 4906 void 4907 fctl_ulp_unsol_cb(fc_local_port_t *port, fc_unsol_buf_t *buf, uchar_t type) 4908 { 4909 int data_cb; 4910 int check_type; 4911 int rval; 4912 uint32_t claimed; 4913 fc_ulp_module_t *mod; 4914 fc_ulp_ports_t *ulp_port; 4915 4916 claimed = 0; 4917 check_type = 1; 4918 4919 switch ((buf->ub_frame.r_ctl) & R_CTL_ROUTING) { 4920 case R_CTL_DEVICE_DATA: 4921 data_cb = 1; 4922 break; 4923 4924 case R_CTL_EXTENDED_SVC: 4925 check_type = 0; 4926 /* FALLTHROUGH */ 4927 4928 case R_CTL_FC4_SVC: 4929 data_cb = 0; 4930 break; 4931 4932 default: 4933 mutex_enter(&port->fp_mutex); 4934 ASSERT(port->fp_active_ubs > 0); 4935 if (--(port->fp_active_ubs) == 0) { 4936 port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB; 4937 } 4938 mutex_exit(&port->fp_mutex); 4939 port->fp_fca_tran->fca_ub_release(port->fp_fca_handle, 4940 1, &buf->ub_token); 4941 return; 4942 } 4943 4944 rw_enter(&fctl_ulp_lock, RW_READER); 4945 for (mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 4946 if (check_type && mod->mod_info->ulp_type != type) { 4947 continue; 4948 } 4949 4950 rw_enter(&fctl_mod_ports_lock, RW_READER); 4951 ulp_port = fctl_get_ulp_port(mod, port); 4952 rw_exit(&fctl_mod_ports_lock); 4953 4954 if (ulp_port == NULL) { 4955 continue; 4956 } 4957 4958 mutex_enter(&ulp_port->port_mutex); 4959 if (FCTL_DISALLOW_CALLBACKS(ulp_port->port_dstate)) { 4960 mutex_exit(&ulp_port->port_mutex); 4961 continue; 4962 } 4963 mutex_exit(&ulp_port->port_mutex); 4964 4965 if (data_cb == 1) { 4966 rval = mod->mod_info->ulp_data_callback( 4967 mod->mod_info->ulp_handle, 4968 (opaque_t)port, buf, claimed); 4969 } else { 4970 rval = mod->mod_info->ulp_els_callback( 4971 mod->mod_info->ulp_handle, 4972 (opaque_t)port, buf, claimed); 4973 } 4974 4975 if (rval == FC_SUCCESS && claimed == 0) { 4976 claimed = 1; 4977 } 4978 } 4979 rw_exit(&fctl_ulp_lock); 4980 4981 if (claimed == 0) { 4982 /* 4983 * We should actually RJT since nobody claimed it. 4984 */ 4985 mutex_enter(&port->fp_mutex); 4986 ASSERT(port->fp_active_ubs > 0); 4987 if (--(port->fp_active_ubs) == 0) { 4988 port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB; 4989 } 4990 mutex_exit(&port->fp_mutex); 4991 port->fp_fca_tran->fca_ub_release(port->fp_fca_handle, 4992 1, &buf->ub_token); 4993 4994 } else { 4995 mutex_enter(&port->fp_mutex); 4996 if (--port->fp_active_ubs == 0) { 4997 port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB; 4998 } 4999 mutex_exit(&port->fp_mutex); 5000 } 5001 } 5002 5003 5004 /* 5005 * Both fd_mutex and pd_mutex are held (in that order) coming in to this func 5006 * 5007 * With all these mutexes held, we should make sure this function does not eat 5008 * up much time. 5009 */ 5010 void 5011 fctl_copy_portmap_held(fc_portmap_t *map, fc_remote_port_t *pd) 5012 { 5013 fc_remote_node_t *node; 5014 5015 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 5016 5017 map->map_pwwn = pd->pd_port_name; 5018 map->map_did = pd->pd_port_id; 5019 map->map_hard_addr = pd->pd_hard_addr; 5020 map->map_state = pd->pd_state; 5021 map->map_type = pd->pd_type; 5022 map->map_flags = 0; 5023 5024 ASSERT(map->map_type <= PORT_DEVICE_DELETE); 5025 5026 bcopy(pd->pd_fc4types, map->map_fc4_types, sizeof (pd->pd_fc4types)); 5027 5028 node = pd->pd_remote_nodep; 5029 5030 ASSERT(MUTEX_HELD(&node->fd_mutex)); 5031 5032 if (node) { 5033 map->map_nwwn = node->fd_node_name; 5034 } 5035 map->map_pd = pd; 5036 } 5037 5038 void 5039 fctl_copy_portmap(fc_portmap_t *map, fc_remote_port_t *pd) 5040 { 5041 fc_remote_node_t *node; 5042 5043 ASSERT(!MUTEX_HELD(&pd->pd_mutex)); 5044 5045 mutex_enter(&pd->pd_mutex); 5046 map->map_pwwn = pd->pd_port_name; 5047 map->map_did = pd->pd_port_id; 5048 map->map_hard_addr = pd->pd_hard_addr; 5049 map->map_state = pd->pd_state; 5050 map->map_type = pd->pd_type; 5051 map->map_flags = 0; 5052 5053 ASSERT(map->map_type <= PORT_DEVICE_DELETE); 5054 5055 bcopy(pd->pd_fc4types, map->map_fc4_types, sizeof (pd->pd_fc4types)); 5056 5057 node = pd->pd_remote_nodep; 5058 mutex_exit(&pd->pd_mutex); 5059 5060 if (node) { 5061 mutex_enter(&node->fd_mutex); 5062 map->map_nwwn = node->fd_node_name; 5063 mutex_exit(&node->fd_mutex); 5064 } 5065 map->map_pd = pd; 5066 } 5067 5068 5069 static int 5070 fctl_update_host_ns_values(fc_local_port_t *port, fc_ns_cmd_t *ns_req) 5071 { 5072 int rval = FC_SUCCESS; 5073 5074 switch (ns_req->ns_cmd) { 5075 case NS_RFT_ID: { 5076 int count; 5077 uint32_t *src; 5078 uint32_t *dst; 5079 ns_rfc_type_t *rfc; 5080 5081 rfc = (ns_rfc_type_t *)ns_req->ns_req_payload; 5082 5083 mutex_enter(&port->fp_mutex); 5084 src = (uint32_t *)port->fp_fc4_types; 5085 dst = (uint32_t *)rfc->rfc_types; 5086 5087 for (count = 0; count < 8; count++) { 5088 *src++ |= *dst++; 5089 } 5090 mutex_exit(&port->fp_mutex); 5091 5092 break; 5093 } 5094 5095 case NS_RSPN_ID: { 5096 ns_spn_t *spn; 5097 5098 spn = (ns_spn_t *)ns_req->ns_req_payload; 5099 5100 mutex_enter(&port->fp_mutex); 5101 port->fp_sym_port_namelen = spn->spn_len; 5102 if (spn->spn_len) { 5103 bcopy((caddr_t)spn + sizeof (ns_spn_t), 5104 port->fp_sym_port_name, spn->spn_len); 5105 } 5106 mutex_exit(&port->fp_mutex); 5107 5108 break; 5109 } 5110 5111 case NS_RSNN_NN: { 5112 ns_snn_t *snn; 5113 5114 snn = (ns_snn_t *)ns_req->ns_req_payload; 5115 5116 mutex_enter(&port->fp_mutex); 5117 port->fp_sym_node_namelen = snn->snn_len; 5118 if (snn->snn_len) { 5119 bcopy((caddr_t)snn + sizeof (ns_snn_t), 5120 port->fp_sym_node_name, snn->snn_len); 5121 } 5122 mutex_exit(&port->fp_mutex); 5123 5124 break; 5125 } 5126 5127 case NS_RIP_NN: { 5128 ns_rip_t *rip; 5129 5130 rip = (ns_rip_t *)ns_req->ns_req_payload; 5131 5132 mutex_enter(&port->fp_mutex); 5133 bcopy(rip->rip_ip_addr, port->fp_ip_addr, 5134 sizeof (rip->rip_ip_addr)); 5135 mutex_exit(&port->fp_mutex); 5136 5137 break; 5138 } 5139 5140 case NS_RIPA_NN: { 5141 ns_ipa_t *ipa; 5142 5143 ipa = (ns_ipa_t *)ns_req->ns_req_payload; 5144 5145 mutex_enter(&port->fp_mutex); 5146 bcopy(ipa->ipa_value, port->fp_ipa, sizeof (ipa->ipa_value)); 5147 mutex_exit(&port->fp_mutex); 5148 5149 break; 5150 } 5151 5152 default: 5153 rval = FC_BADOBJECT; 5154 break; 5155 } 5156 5157 return (rval); 5158 } 5159 5160 5161 static int 5162 fctl_retrieve_host_ns_values(fc_local_port_t *port, fc_ns_cmd_t *ns_req) 5163 { 5164 int rval = FC_SUCCESS; 5165 5166 switch (ns_req->ns_cmd) { 5167 case NS_GFT_ID: { 5168 ns_rfc_type_t *rfc; 5169 5170 rfc = (ns_rfc_type_t *)ns_req->ns_resp_payload; 5171 5172 mutex_enter(&port->fp_mutex); 5173 bcopy(port->fp_fc4_types, rfc->rfc_types, 5174 sizeof (rfc->rfc_types)); 5175 mutex_exit(&port->fp_mutex); 5176 break; 5177 } 5178 5179 case NS_GSPN_ID: { 5180 ns_spn_t *spn; 5181 5182 spn = (ns_spn_t *)ns_req->ns_resp_payload; 5183 5184 mutex_enter(&port->fp_mutex); 5185 spn->spn_len = port->fp_sym_port_namelen; 5186 if (spn->spn_len) { 5187 bcopy(port->fp_sym_port_name, (caddr_t)spn + 5188 sizeof (ns_spn_t), spn->spn_len); 5189 } 5190 mutex_exit(&port->fp_mutex); 5191 5192 break; 5193 } 5194 5195 case NS_GSNN_NN: { 5196 ns_snn_t *snn; 5197 5198 snn = (ns_snn_t *)ns_req->ns_resp_payload; 5199 5200 mutex_enter(&port->fp_mutex); 5201 snn->snn_len = port->fp_sym_node_namelen; 5202 if (snn->snn_len) { 5203 bcopy(port->fp_sym_node_name, (caddr_t)snn + 5204 sizeof (ns_snn_t), snn->snn_len); 5205 } 5206 mutex_exit(&port->fp_mutex); 5207 5208 break; 5209 } 5210 5211 case NS_GIP_NN: { 5212 ns_rip_t *rip; 5213 5214 rip = (ns_rip_t *)ns_req->ns_resp_payload; 5215 5216 mutex_enter(&port->fp_mutex); 5217 bcopy(port->fp_ip_addr, rip->rip_ip_addr, 5218 sizeof (rip->rip_ip_addr)); 5219 mutex_exit(&port->fp_mutex); 5220 5221 break; 5222 } 5223 5224 case NS_GIPA_NN: { 5225 ns_ipa_t *ipa; 5226 5227 ipa = (ns_ipa_t *)ns_req->ns_resp_payload; 5228 5229 mutex_enter(&port->fp_mutex); 5230 bcopy(port->fp_ipa, ipa->ipa_value, sizeof (ipa->ipa_value)); 5231 mutex_exit(&port->fp_mutex); 5232 5233 break; 5234 } 5235 5236 default: 5237 rval = FC_BADOBJECT; 5238 break; 5239 } 5240 5241 return (rval); 5242 } 5243 5244 5245 fctl_ns_req_t * 5246 fctl_alloc_ns_cmd(uint32_t cmd_len, uint32_t resp_len, uint32_t data_len, 5247 uint32_t ns_flags, int sleep) 5248 { 5249 fctl_ns_req_t *ns_cmd; 5250 5251 ns_cmd = kmem_zalloc(sizeof (*ns_cmd), sleep); 5252 if (ns_cmd == NULL) { 5253 return (NULL); 5254 } 5255 5256 if (cmd_len) { 5257 ns_cmd->ns_cmd_buf = kmem_zalloc(cmd_len, sleep); 5258 if (ns_cmd->ns_cmd_buf == NULL) { 5259 kmem_free(ns_cmd, sizeof (*ns_cmd)); 5260 return (NULL); 5261 } 5262 ns_cmd->ns_cmd_size = cmd_len; 5263 } 5264 5265 ns_cmd->ns_resp_size = resp_len; 5266 5267 if (data_len) { 5268 ns_cmd->ns_data_buf = kmem_zalloc(data_len, sleep); 5269 if (ns_cmd->ns_data_buf == NULL) { 5270 if (ns_cmd->ns_cmd_buf && cmd_len) { 5271 kmem_free(ns_cmd->ns_cmd_buf, cmd_len); 5272 } 5273 kmem_free(ns_cmd, sizeof (*ns_cmd)); 5274 return (NULL); 5275 } 5276 ns_cmd->ns_data_len = data_len; 5277 } 5278 ns_cmd->ns_flags = ns_flags; 5279 5280 return (ns_cmd); 5281 } 5282 5283 5284 void 5285 fctl_free_ns_cmd(fctl_ns_req_t *ns_cmd) 5286 { 5287 if (ns_cmd->ns_cmd_size && ns_cmd->ns_cmd_buf) { 5288 kmem_free(ns_cmd->ns_cmd_buf, ns_cmd->ns_cmd_size); 5289 } 5290 if (ns_cmd->ns_data_len && ns_cmd->ns_data_buf) { 5291 kmem_free(ns_cmd->ns_data_buf, ns_cmd->ns_data_len); 5292 } 5293 kmem_free(ns_cmd, sizeof (*ns_cmd)); 5294 } 5295 5296 5297 int 5298 fctl_ulp_port_ioctl(fc_local_port_t *port, dev_t dev, int cmd, 5299 intptr_t data, int mode, cred_t *credp, int *rval) 5300 { 5301 int ret; 5302 int save; 5303 uint32_t claimed; 5304 fc_ulp_module_t *mod; 5305 fc_ulp_ports_t *ulp_port; 5306 5307 save = *rval; 5308 *rval = ENOTTY; 5309 5310 rw_enter(&fctl_ulp_lock, RW_READER); 5311 for (claimed = 0, mod = fctl_ulp_modules; mod; mod = mod->mod_next) { 5312 rw_enter(&fctl_mod_ports_lock, RW_READER); 5313 ulp_port = fctl_get_ulp_port(mod, port); 5314 rw_exit(&fctl_mod_ports_lock); 5315 5316 if (ulp_port == NULL) { 5317 continue; 5318 } 5319 5320 mutex_enter(&ulp_port->port_mutex); 5321 if (FCTL_DISALLOW_CALLBACKS(ulp_port->port_dstate) || 5322 mod->mod_info->ulp_port_ioctl == NULL) { 5323 mutex_exit(&ulp_port->port_mutex); 5324 continue; 5325 } 5326 mutex_exit(&ulp_port->port_mutex); 5327 5328 ret = mod->mod_info->ulp_port_ioctl( 5329 mod->mod_info->ulp_handle, (opaque_t)port, 5330 dev, cmd, data, mode, credp, rval, claimed); 5331 5332 if (ret == FC_SUCCESS && claimed == 0) { 5333 claimed = 1; 5334 } 5335 } 5336 rw_exit(&fctl_ulp_lock); 5337 5338 ret = *rval; 5339 *rval = save; 5340 5341 return (ret); 5342 } 5343 5344 /* 5345 * raise power if necessary, and set the port busy 5346 * 5347 * this may cause power to be raised, so no power related locks should 5348 * be held 5349 */ 5350 int 5351 fc_ulp_busy_port(opaque_t port_handle) 5352 { 5353 fc_local_port_t *port = port_handle; 5354 5355 return (fctl_busy_port(port)); 5356 } 5357 5358 void 5359 fc_ulp_idle_port(opaque_t port_handle) 5360 { 5361 fc_local_port_t *port = port_handle; 5362 fctl_idle_port(port); 5363 } 5364 5365 void 5366 fc_ulp_copy_portmap(fc_portmap_t *map, opaque_t pd) 5367 { 5368 fctl_copy_portmap(map, (fc_remote_port_t *)pd); 5369 } 5370 5371 5372 int 5373 fc_ulp_get_npiv_port_num(opaque_t port_handle) 5374 { 5375 int portsnum = 0; 5376 fc_local_port_t *port = port_handle; 5377 fc_local_port_t *tmpport; 5378 5379 mutex_enter(&port->fp_mutex); 5380 tmpport = port->fp_port_next; 5381 if (!tmpport) { 5382 mutex_exit(&port->fp_mutex); 5383 return (portsnum); 5384 } 5385 while (tmpport != port) { 5386 portsnum ++; 5387 tmpport = tmpport->fp_port_next; 5388 } 5389 mutex_exit(&port->fp_mutex); 5390 return (portsnum); 5391 } 5392 5393 fc_local_port_t * 5394 fc_get_npiv_port(fc_local_port_t *phyport, la_wwn_t *pwwn) 5395 { 5396 fc_fca_port_t *fca_port; 5397 fc_local_port_t *tmpPort = phyport; 5398 5399 mutex_enter(&fctl_port_lock); 5400 5401 for (fca_port = fctl_fca_portlist; fca_port != NULL; 5402 fca_port = fca_port->port_next) { 5403 tmpPort = fca_port->port_handle; 5404 if (tmpPort == NULL) { 5405 continue; 5406 } 5407 mutex_enter(&tmpPort->fp_mutex); 5408 if (bcmp(tmpPort->fp_service_params.nport_ww_name.raw_wwn, 5409 pwwn->raw_wwn, sizeof (la_wwn_t)) == 0) { 5410 mutex_exit(&tmpPort->fp_mutex); 5411 mutex_exit(&fctl_port_lock); 5412 return (tmpPort); 5413 } 5414 mutex_exit(&tmpPort->fp_mutex); 5415 } 5416 5417 mutex_exit(&fctl_port_lock); 5418 5419 return (NULL); 5420 } 5421 5422 int 5423 fc_ulp_get_npiv_port_list(opaque_t port_handle, char *pathList) 5424 { 5425 int portsnum = 0; 5426 fc_local_port_t *port = port_handle; 5427 fc_local_port_t *tmpport; 5428 5429 mutex_enter(&port->fp_mutex); 5430 tmpport = port->fp_port_next; 5431 if (!tmpport || (port->fp_npiv_type == FC_NPIV_PORT)) { 5432 mutex_exit(&port->fp_mutex); 5433 return (portsnum); 5434 } 5435 5436 while (tmpport != port) { 5437 (void) ddi_pathname(tmpport->fp_port_dip, 5438 &pathList[MAXPATHLEN * portsnum]); 5439 portsnum ++; 5440 tmpport = tmpport->fp_port_next; 5441 } 5442 mutex_exit(&port->fp_mutex); 5443 5444 return (portsnum); 5445 } 5446 5447 5448 fc_local_port_t * 5449 fc_delete_npiv_port(fc_local_port_t *port, la_wwn_t *pwwn) 5450 { 5451 fc_local_port_t *tmpport; 5452 5453 mutex_enter(&port->fp_mutex); 5454 tmpport = port->fp_port_next; 5455 if (!tmpport || (port->fp_npiv_type == FC_NPIV_PORT)) { 5456 mutex_exit(&port->fp_mutex); 5457 return (NULL); 5458 } 5459 5460 while (tmpport != port) { 5461 if ((bcmp(tmpport->fp_service_params.nport_ww_name.raw_wwn, 5462 pwwn->raw_wwn, sizeof (la_wwn_t)) == 0) && 5463 (tmpport->fp_npiv_state == 0)) { 5464 tmpport->fp_npiv_state = FC_NPIV_DELETING; 5465 mutex_exit(&port->fp_mutex); 5466 return (tmpport); 5467 } 5468 tmpport = tmpport->fp_port_next; 5469 } 5470 5471 mutex_exit(&port->fp_mutex); 5472 return (NULL); 5473 } 5474 5475 /* 5476 * Get the list of Adapters. On multi-ported adapters, 5477 * only ONE port on the adapter will be returned. 5478 * pathList should be (count * MAXPATHLEN) long. 5479 * The return value will be set to the number of 5480 * HBAs that were found on the system. If the value 5481 * is greater than count, the routine should be retried 5482 * with a larger buffer. 5483 */ 5484 int 5485 fc_ulp_get_adapter_paths(char *pathList, int count) 5486 { 5487 fc_fca_port_t *fca_port; 5488 int in = 0, out = 0, check, skip, maxPorts = 0; 5489 fc_local_port_t **portList; 5490 fc_local_port_t *new_port, *stored_port; 5491 fca_hba_fru_details_t *new_fru, *stored_fru; 5492 5493 ASSERT(pathList != NULL); 5494 5495 /* First figure out how many ports we have */ 5496 mutex_enter(&fctl_port_lock); 5497 5498 for (fca_port = fctl_fca_portlist; fca_port != NULL; 5499 fca_port = fca_port->port_next) { 5500 maxPorts ++; 5501 } 5502 5503 /* Now allocate a buffer to store all the pointers for comparisons */ 5504 portList = kmem_zalloc(sizeof (fc_local_port_t *) * maxPorts, KM_SLEEP); 5505 5506 for (fca_port = fctl_fca_portlist; fca_port != NULL; 5507 fca_port = fca_port->port_next) { 5508 skip = 0; 5509 5510 /* Lock the new port for subsequent comparisons */ 5511 new_port = fca_port->port_handle; 5512 mutex_enter(&new_port->fp_mutex); 5513 new_fru = &new_port->fp_hba_port_attrs.hba_fru_details; 5514 5515 /* Filter out secondary ports from the list */ 5516 for (check = 0; check < out; check++) { 5517 if (portList[check] == NULL) { 5518 continue; 5519 } 5520 /* Guard against duplicates (should never happen) */ 5521 if (portList[check] == fca_port->port_handle) { 5522 /* Same port */ 5523 skip = 1; 5524 break; 5525 } 5526 5527 /* Lock the already stored port for comparison */ 5528 stored_port = portList[check]; 5529 mutex_enter(&stored_port->fp_mutex); 5530 stored_fru = 5531 &stored_port->fp_hba_port_attrs.hba_fru_details; 5532 5533 /* Are these ports on the same HBA? */ 5534 if (new_fru->high == stored_fru->high && 5535 new_fru->low == stored_fru->low) { 5536 /* Now double check driver */ 5537 if (strncmp( 5538 new_port->fp_hba_port_attrs.driver_name, 5539 stored_port->fp_hba_port_attrs.driver_name, 5540 FCHBA_DRIVER_NAME_LEN) == 0) { 5541 /* we don't need to grow the list */ 5542 skip = 1; 5543 /* looking at a lower port index? */ 5544 if (new_fru->port_index < 5545 stored_fru->port_index) { 5546 /* Replace the port in list */ 5547 mutex_exit( 5548 &stored_port->fp_mutex); 5549 if (new_port->fp_npiv_type == 5550 FC_NPIV_PORT) { 5551 break; 5552 } 5553 portList[check] = new_port; 5554 break; 5555 } /* Else, just skip this port */ 5556 } 5557 } 5558 5559 mutex_exit(&stored_port->fp_mutex); 5560 } 5561 mutex_exit(&new_port->fp_mutex); 5562 5563 if (!skip) { 5564 /* 5565 * Either this is the first port for this HBA, or 5566 * it's a secondary port and we haven't stored the 5567 * primary/first port for that HBA. In the latter case, 5568 * will just filter it out as we proceed to loop. 5569 */ 5570 if (fca_port->port_handle->fp_npiv_type == 5571 FC_NPIV_PORT) { 5572 continue; 5573 } else { 5574 portList[out++] = fca_port->port_handle; 5575 } 5576 } 5577 } 5578 5579 if (out <= count) { 5580 for (in = 0; in < out; in++) { 5581 (void) ddi_pathname(portList[in]->fp_port_dip, 5582 &pathList[MAXPATHLEN * in]); 5583 } 5584 } 5585 mutex_exit(&fctl_port_lock); 5586 kmem_free(portList, sizeof (*portList) * maxPorts); 5587 return (out); 5588 } 5589 5590 uint32_t 5591 fc_ulp_get_rscn_count(opaque_t port_handle) 5592 { 5593 uint32_t count; 5594 fc_local_port_t *port; 5595 5596 port = (fc_local_port_t *)port_handle; 5597 mutex_enter(&port->fp_mutex); 5598 count = port->fp_rscn_count; 5599 mutex_exit(&port->fp_mutex); 5600 5601 return (count); 5602 } 5603 5604 5605 /* 5606 * This function is a very similar to fctl_add_orphan except that it expects 5607 * that the fp_mutex and pd_mutex of the pd passed in are held coming in. 5608 * 5609 * Note that there is a lock hierarchy here (fp_mutex should be held first) but 5610 * since this function could be called with a different pd's pd_mutex held, we 5611 * should take care not to release fp_mutex in this function. 5612 */ 5613 int 5614 fctl_add_orphan_held(fc_local_port_t *port, fc_remote_port_t *pd) 5615 { 5616 int rval = FC_FAILURE; 5617 la_wwn_t pwwn; 5618 fc_orphan_t *orp; 5619 fc_orphan_t *orphan; 5620 5621 ASSERT(MUTEX_HELD(&port->fp_mutex)); 5622 ASSERT(MUTEX_HELD(&pd->pd_mutex)); 5623 5624 pwwn = pd->pd_port_name; 5625 5626 for (orp = port->fp_orphan_list; orp != NULL; orp = orp->orp_next) { 5627 if (fctl_wwn_cmp(&orp->orp_pwwn, &pwwn) == 0) { 5628 return (FC_SUCCESS); 5629 } 5630 } 5631 5632 orphan = kmem_zalloc(sizeof (*orphan), KM_NOSLEEP); 5633 if (orphan) { 5634 orphan->orp_pwwn = pwwn; 5635 orphan->orp_tstamp = ddi_get_lbolt(); 5636 5637 if (port->fp_orphan_list) { 5638 ASSERT(port->fp_orphan_count > 0); 5639 orphan->orp_next = port->fp_orphan_list; 5640 } 5641 port->fp_orphan_list = orphan; 5642 port->fp_orphan_count++; 5643 5644 rval = FC_SUCCESS; 5645 } 5646 5647 return (rval); 5648 } 5649 5650 int 5651 fctl_add_orphan(fc_local_port_t *port, fc_remote_port_t *pd, int sleep) 5652 { 5653 int rval = FC_FAILURE; 5654 la_wwn_t pwwn; 5655 fc_orphan_t *orp; 5656 fc_orphan_t *orphan; 5657 5658 mutex_enter(&port->fp_mutex); 5659 5660 mutex_enter(&pd->pd_mutex); 5661 pwwn = pd->pd_port_name; 5662 mutex_exit(&pd->pd_mutex); 5663 5664 for (orp = port->fp_orphan_list; orp != NULL; orp = orp->orp_next) { 5665 if (fctl_wwn_cmp(&orp->orp_pwwn, &pwwn) == 0) { 5666 mutex_exit(&port->fp_mutex); 5667 return (FC_SUCCESS); 5668 } 5669 } 5670 mutex_exit(&port->fp_mutex); 5671 5672 orphan = kmem_zalloc(sizeof (*orphan), sleep); 5673 if (orphan != NULL) { 5674 mutex_enter(&port->fp_mutex); 5675 5676 orphan->orp_pwwn = pwwn; 5677 orphan->orp_tstamp = ddi_get_lbolt(); 5678 5679 if (port->fp_orphan_list) { 5680 ASSERT(port->fp_orphan_count > 0); 5681 orphan->orp_next = port->fp_orphan_list; 5682 } 5683 port->fp_orphan_list = orphan; 5684 port->fp_orphan_count++; 5685 mutex_exit(&port->fp_mutex); 5686 5687 rval = FC_SUCCESS; 5688 } 5689 5690 return (rval); 5691 } 5692 5693 5694 int 5695 fctl_remove_if_orphan(fc_local_port_t *port, la_wwn_t *pwwn) 5696 { 5697 int rval = FC_FAILURE; 5698 fc_orphan_t *prev = NULL; 5699 fc_orphan_t *orp; 5700 5701 mutex_enter(&port->fp_mutex); 5702 for (orp = port->fp_orphan_list; orp != NULL; orp = orp->orp_next) { 5703 if (fctl_wwn_cmp(&orp->orp_pwwn, pwwn) == 0) { 5704 if (prev) { 5705 prev->orp_next = orp->orp_next; 5706 } else { 5707 ASSERT(port->fp_orphan_list == orp); 5708 port->fp_orphan_list = orp->orp_next; 5709 } 5710 port->fp_orphan_count--; 5711 rval = FC_SUCCESS; 5712 break; 5713 } 5714 prev = orp; 5715 } 5716 mutex_exit(&port->fp_mutex); 5717 5718 if (rval == FC_SUCCESS) { 5719 kmem_free(orp, sizeof (*orp)); 5720 } 5721 5722 return (rval); 5723 } 5724 5725 5726 static void 5727 fctl_print_if_not_orphan(fc_local_port_t *port, fc_remote_port_t *pd) 5728 { 5729 char ww_name[17]; 5730 la_wwn_t pwwn; 5731 fc_orphan_t *orp; 5732 5733 mutex_enter(&port->fp_mutex); 5734 5735 mutex_enter(&pd->pd_mutex); 5736 pwwn = pd->pd_port_name; 5737 mutex_exit(&pd->pd_mutex); 5738 5739 for (orp = port->fp_orphan_list; orp != NULL; orp = orp->orp_next) { 5740 if (fctl_wwn_cmp(&orp->orp_pwwn, &pwwn) == 0) { 5741 mutex_exit(&port->fp_mutex); 5742 return; 5743 } 5744 } 5745 mutex_exit(&port->fp_mutex); 5746 5747 fc_wwn_to_str(&pwwn, ww_name); 5748 5749 cmn_err(CE_WARN, "!fctl(%d): N_x Port with D_ID=%x, PWWN=%s" 5750 " disappeared from fabric", port->fp_instance, 5751 pd->pd_port_id.port_id, ww_name); 5752 } 5753 5754 5755 /* ARGSUSED */ 5756 static void 5757 fctl_link_reset_done(opaque_t port_handle, uchar_t result) 5758 { 5759 fc_local_port_t *port = port_handle; 5760 5761 mutex_enter(&port->fp_mutex); 5762 port->fp_soft_state &= ~FP_SOFT_IN_LINK_RESET; 5763 mutex_exit(&port->fp_mutex); 5764 5765 fctl_idle_port(port); 5766 } 5767 5768 5769 static int 5770 fctl_error(int fc_errno, char **errmsg) 5771 { 5772 int count; 5773 5774 for (count = 0; count < sizeof (fc_errlist) / 5775 sizeof (fc_errlist[0]); count++) { 5776 if (fc_errlist[count].fc_errno == fc_errno) { 5777 *errmsg = fc_errlist[count].fc_errname; 5778 return (FC_SUCCESS); 5779 } 5780 } 5781 *errmsg = fctl_undefined; 5782 5783 return (FC_FAILURE); 5784 } 5785 5786 5787 /* 5788 * Return number of successful translations. 5789 * Anybody with some userland programming experience would have 5790 * figured it by now that the return value exactly resembles that 5791 * of scanf(3c). This function returns a count of successful 5792 * translations. It could range from 0 (no match for state, reason, 5793 * action, expln) to 4 (successful matches for all state, reason, 5794 * action, expln) and where translation isn't successful into a 5795 * friendlier message the relevent field is set to "Undefined" 5796 */ 5797 static int 5798 fctl_pkt_error(fc_packet_t *pkt, char **state, char **reason, 5799 char **action, char **expln) 5800 { 5801 int ret; 5802 int len; 5803 int index; 5804 fc_pkt_error_t *error; 5805 fc_pkt_reason_t *reason_b; /* Base pointer */ 5806 fc_pkt_action_t *action_b; /* Base pointer */ 5807 fc_pkt_expln_t *expln_b; /* Base pointer */ 5808 5809 ret = 0; 5810 *state = *reason = *action = *expln = fctl_undefined; 5811 5812 len = sizeof (fc_pkt_errlist) / sizeof fc_pkt_errlist[0]; 5813 for (index = 0; index < len; index++) { 5814 error = fc_pkt_errlist + index; 5815 if (pkt->pkt_state == error->pkt_state) { 5816 *state = error->pkt_msg; 5817 ret++; 5818 5819 reason_b = error->pkt_reason; 5820 action_b = error->pkt_action; 5821 expln_b = error->pkt_expln; 5822 5823 while (reason_b != NULL && 5824 reason_b->reason_val != FC_REASON_INVALID) { 5825 if (reason_b->reason_val == pkt->pkt_reason) { 5826 *reason = reason_b->reason_msg; 5827 ret++; 5828 break; 5829 } 5830 reason_b++; 5831 } 5832 5833 while (action_b != NULL && 5834 action_b->action_val != FC_ACTION_INVALID) { 5835 if (action_b->action_val == pkt->pkt_action) { 5836 *action = action_b->action_msg; 5837 ret++; 5838 break; 5839 } 5840 action_b++; 5841 } 5842 5843 while (expln_b != NULL && 5844 expln_b->expln_val != FC_EXPLN_INVALID) { 5845 if (expln_b->expln_val == pkt->pkt_expln) { 5846 *expln = expln_b->expln_msg; 5847 ret++; 5848 break; 5849 } 5850 expln_b++; 5851 } 5852 break; 5853 } 5854 } 5855 5856 return (ret); 5857 } 5858 5859 5860 /* 5861 * Remove all port devices that are marked OLD, remove 5862 * corresponding node devices (fc_remote_node_t) 5863 */ 5864 void 5865 fctl_remove_oldies(fc_local_port_t *port) 5866 { 5867 int index; 5868 int initiator; 5869 fc_remote_node_t *node; 5870 struct pwwn_hash *head; 5871 fc_remote_port_t *pd; 5872 fc_remote_port_t *old_pd; 5873 fc_remote_port_t *last_pd; 5874 5875 /* 5876 * Nuke all OLD devices 5877 */ 5878 mutex_enter(&port->fp_mutex); 5879 5880 for (index = 0; index < pwwn_table_size; index++) { 5881 head = &port->fp_pwwn_table[index]; 5882 last_pd = NULL; 5883 pd = head->pwwn_head; 5884 5885 while (pd != NULL) { 5886 mutex_enter(&pd->pd_mutex); 5887 if (pd->pd_type != PORT_DEVICE_OLD) { 5888 mutex_exit(&pd->pd_mutex); 5889 last_pd = pd; 5890 pd = pd->pd_wwn_hnext; 5891 continue; 5892 } 5893 5894 /* 5895 * Remove this from the PWWN hash table 5896 */ 5897 old_pd = pd; 5898 pd = old_pd->pd_wwn_hnext; 5899 5900 if (last_pd == NULL) { 5901 ASSERT(old_pd == head->pwwn_head); 5902 head->pwwn_head = pd; 5903 } else { 5904 last_pd->pd_wwn_hnext = pd; 5905 } 5906 head->pwwn_count--; 5907 /* 5908 * Make sure we tie fp_dev_count to the size of the 5909 * pwwn_table 5910 */ 5911 port->fp_dev_count--; 5912 old_pd->pd_wwn_hnext = NULL; 5913 5914 fctl_delist_did_table(port, old_pd); 5915 node = old_pd->pd_remote_nodep; 5916 ASSERT(node != NULL); 5917 5918 initiator = (old_pd->pd_recepient == 5919 PD_PLOGI_INITIATOR) ? 1 : 0; 5920 5921 mutex_exit(&old_pd->pd_mutex); 5922 5923 if (FC_IS_TOP_SWITCH(port->fp_topology) && initiator) { 5924 mutex_exit(&port->fp_mutex); 5925 5926 (void) fctl_add_orphan(port, old_pd, 5927 KM_NOSLEEP); 5928 } else { 5929 mutex_exit(&port->fp_mutex); 5930 } 5931 5932 if (fctl_destroy_remote_port(port, old_pd) == 0) { 5933 if (node) { 5934 fctl_destroy_remote_node(node); 5935 } 5936 } 5937 5938 mutex_enter(&port->fp_mutex); 5939 } 5940 } 5941 5942 mutex_exit(&port->fp_mutex); 5943 } 5944 5945 5946 static void 5947 fctl_check_alpa_list(fc_local_port_t *port, fc_remote_port_t *pd) 5948 { 5949 ASSERT(MUTEX_HELD(&port->fp_mutex)); 5950 ASSERT(port->fp_topology == FC_TOP_PRIVATE_LOOP); 5951 5952 if (fctl_is_alpa_present(port, pd->pd_port_id.port_id) == FC_SUCCESS) { 5953 return; 5954 } 5955 5956 cmn_err(CE_WARN, "!fctl(%d): AL_PA=0x%x doesn't exist in LILP map", 5957 port->fp_instance, pd->pd_port_id.port_id); 5958 } 5959 5960 5961 static int 5962 fctl_is_alpa_present(fc_local_port_t *port, uchar_t alpa) 5963 { 5964 int index; 5965 5966 ASSERT(MUTEX_HELD(&port->fp_mutex)); 5967 ASSERT(port->fp_topology == FC_TOP_PRIVATE_LOOP); 5968 5969 for (index = 0; index < port->fp_lilp_map.lilp_length; index++) { 5970 if (port->fp_lilp_map.lilp_alpalist[index] == alpa) { 5971 return (FC_SUCCESS); 5972 } 5973 } 5974 5975 return (FC_FAILURE); 5976 } 5977 5978 5979 fc_remote_port_t * 5980 fctl_lookup_pd_by_did(fc_local_port_t *port, uint32_t d_id) 5981 { 5982 int index; 5983 struct pwwn_hash *head; 5984 fc_remote_port_t *pd; 5985 5986 ASSERT(MUTEX_HELD(&port->fp_mutex)); 5987 5988 for (index = 0; index < pwwn_table_size; index++) { 5989 head = &port->fp_pwwn_table[index]; 5990 pd = head->pwwn_head; 5991 5992 while (pd != NULL) { 5993 mutex_enter(&pd->pd_mutex); 5994 if (pd->pd_port_id.port_id == d_id) { 5995 mutex_exit(&pd->pd_mutex); 5996 return (pd); 5997 } 5998 mutex_exit(&pd->pd_mutex); 5999 pd = pd->pd_wwn_hnext; 6000 } 6001 } 6002 6003 return (pd); 6004 } 6005 6006 6007 /* 6008 * trace debugging 6009 */ 6010 void 6011 fc_trace_debug(fc_trace_logq_t *logq, caddr_t name, int dflag, int dlevel, 6012 int errno, const char *fmt, ...) 6013 { 6014 char buf[FC_MAX_TRACE_BUF_LEN + 3]; /* 3 is for "\n" */ 6015 char *bufptr = buf; 6016 va_list ap; 6017 int cnt = 0; 6018 6019 if ((dlevel & dflag) == 0) { 6020 return; 6021 } 6022 6023 if (name) { 6024 cnt = snprintf(buf, FC_MAX_TRACE_BUF_LEN + 1, "%d=>%s::", 6025 logq->il_id++, name); 6026 } else { 6027 cnt = snprintf(buf, FC_MAX_TRACE_BUF_LEN + 1, "%d=>trace::", 6028 logq->il_id++); 6029 } 6030 6031 if (cnt < FC_MAX_TRACE_BUF_LEN) { 6032 va_start(ap, fmt); 6033 cnt += vsnprintf(buf + cnt, FC_MAX_TRACE_BUF_LEN + 1 - cnt, 6034 fmt, ap); 6035 va_end(ap); 6036 } 6037 6038 if (cnt > FC_MAX_TRACE_BUF_LEN) { 6039 cnt = FC_MAX_TRACE_BUF_LEN; 6040 } 6041 if (errno && (cnt < FC_MAX_TRACE_BUF_LEN)) { 6042 cnt += snprintf(buf + cnt, FC_MAX_TRACE_BUF_LEN + 1 - cnt, 6043 "error=0x%x\n", errno); 6044 } 6045 (void) snprintf(buf + cnt, FC_MAX_TRACE_BUF_LEN + 3 - cnt, "\n"); 6046 6047 if (logq && (dlevel & FC_TRACE_LOG_BUF) != 0) { 6048 fc_trace_logmsg(logq, buf, dlevel); 6049 } 6050 6051 /* 6052 * We do not want to print the log numbers that appear as 6053 * random numbers at the console and messages files, to 6054 * the user. 6055 */ 6056 if ((bufptr = strchr(buf, '>')) == NULL) { 6057 /* 6058 * We would have added the a string with "=>" above and so, 6059 * ideally, we should not get here at all. But, if we do, 6060 * we'll just use the full buf. 6061 */ 6062 bufptr = buf; 6063 } else { 6064 bufptr++; 6065 } 6066 6067 switch (dlevel & FC_TRACE_LOG_MASK) { 6068 case FC_TRACE_LOG_CONSOLE: 6069 cmn_err(CE_WARN, "%s", bufptr); 6070 break; 6071 6072 case FC_TRACE_LOG_CONSOLE_MSG: 6073 cmn_err(CE_WARN, "%s", bufptr); 6074 break; 6075 6076 case FC_TRACE_LOG_MSG: 6077 cmn_err(CE_WARN, "!%s", bufptr); 6078 break; 6079 6080 default: 6081 break; 6082 } 6083 } 6084 6085 6086 /* 6087 * This function can block 6088 */ 6089 fc_trace_logq_t * 6090 fc_trace_alloc_logq(int maxsize) 6091 { 6092 fc_trace_logq_t *logq; 6093 6094 logq = kmem_zalloc(sizeof (*logq), KM_SLEEP); 6095 6096 mutex_init(&logq->il_lock, NULL, MUTEX_DRIVER, NULL); 6097 logq->il_hiwat = maxsize; 6098 logq->il_flags |= FC_TRACE_LOGQ_V2; 6099 6100 return (logq); 6101 } 6102 6103 6104 void 6105 fc_trace_free_logq(fc_trace_logq_t *logq) 6106 { 6107 mutex_enter(&logq->il_lock); 6108 while (logq->il_msgh) { 6109 fc_trace_freemsg(logq); 6110 } 6111 mutex_exit(&logq->il_lock); 6112 6113 mutex_destroy(&logq->il_lock); 6114 kmem_free(logq, sizeof (*logq)); 6115 } 6116 6117 6118 /* ARGSUSED */ 6119 void 6120 fc_trace_logmsg(fc_trace_logq_t *logq, caddr_t buf, int level) 6121 { 6122 int qfull = 0; 6123 fc_trace_dmsg_t *dmsg; 6124 6125 dmsg = kmem_alloc(sizeof (*dmsg), KM_NOSLEEP); 6126 if (dmsg == NULL) { 6127 mutex_enter(&logq->il_lock); 6128 logq->il_afail++; 6129 mutex_exit(&logq->il_lock); 6130 6131 return; 6132 } 6133 6134 gethrestime(&dmsg->id_time); 6135 6136 dmsg->id_size = strlen(buf) + 1; 6137 dmsg->id_buf = kmem_alloc(dmsg->id_size, KM_NOSLEEP); 6138 if (dmsg->id_buf == NULL) { 6139 kmem_free(dmsg, sizeof (*dmsg)); 6140 6141 mutex_enter(&logq->il_lock); 6142 logq->il_afail++; 6143 mutex_exit(&logq->il_lock); 6144 6145 return; 6146 } 6147 bcopy(buf, dmsg->id_buf, strlen(buf)); 6148 dmsg->id_buf[strlen(buf)] = '\0'; 6149 6150 mutex_enter(&logq->il_lock); 6151 6152 logq->il_size += dmsg->id_size; 6153 if (logq->il_size >= logq->il_hiwat) { 6154 qfull = 1; 6155 } 6156 6157 if (qfull) { 6158 fc_trace_freemsg(logq); 6159 } 6160 6161 dmsg->id_next = NULL; 6162 if (logq->il_msgt) { 6163 logq->il_msgt->id_next = dmsg; 6164 } else { 6165 ASSERT(logq->il_msgh == NULL); 6166 logq->il_msgh = dmsg; 6167 } 6168 logq->il_msgt = dmsg; 6169 6170 mutex_exit(&logq->il_lock); 6171 } 6172 6173 6174 static void 6175 fc_trace_freemsg(fc_trace_logq_t *logq) 6176 { 6177 fc_trace_dmsg_t *dmsg; 6178 6179 ASSERT(MUTEX_HELD(&logq->il_lock)); 6180 6181 if ((dmsg = logq->il_msgh) != NULL) { 6182 logq->il_msgh = dmsg->id_next; 6183 if (logq->il_msgh == NULL) { 6184 logq->il_msgt = NULL; 6185 } 6186 6187 logq->il_size -= dmsg->id_size; 6188 kmem_free(dmsg->id_buf, dmsg->id_size); 6189 kmem_free(dmsg, sizeof (*dmsg)); 6190 } else { 6191 ASSERT(logq->il_msgt == NULL); 6192 } 6193 } 6194 6195 /* 6196 * Used by T11 FC-HBA to fetch discovered ports by index. 6197 * Returns NULL if the index isn't valid. 6198 */ 6199 fc_remote_port_t * 6200 fctl_lookup_pd_by_index(fc_local_port_t *port, uint32_t index) 6201 { 6202 int outer; 6203 int match = 0; 6204 struct pwwn_hash *head; 6205 fc_remote_port_t *pd; 6206 6207 ASSERT(MUTEX_HELD(&port->fp_mutex)); 6208 6209 for (outer = 0; 6210 outer < pwwn_table_size && match <= index; 6211 outer++) { 6212 head = &port->fp_pwwn_table[outer]; 6213 pd = head->pwwn_head; 6214 if (pd != NULL) match ++; 6215 6216 while (pd != NULL && match <= index) { 6217 pd = pd->pd_wwn_hnext; 6218 if (pd != NULL) match ++; 6219 } 6220 } 6221 6222 return (pd); 6223 } 6224 6225 /* 6226 * Search for a matching Node or Port WWN in the discovered port list 6227 */ 6228 fc_remote_port_t * 6229 fctl_lookup_pd_by_wwn(fc_local_port_t *port, la_wwn_t wwn) 6230 { 6231 int index; 6232 struct pwwn_hash *head; 6233 fc_remote_port_t *pd; 6234 6235 ASSERT(MUTEX_HELD(&port->fp_mutex)); 6236 6237 for (index = 0; index < pwwn_table_size; index++) { 6238 head = &port->fp_pwwn_table[index]; 6239 pd = head->pwwn_head; 6240 6241 while (pd != NULL) { 6242 mutex_enter(&pd->pd_mutex); 6243 if (bcmp(pd->pd_port_name.raw_wwn, wwn.raw_wwn, 6244 sizeof (la_wwn_t)) == 0) { 6245 mutex_exit(&pd->pd_mutex); 6246 return (pd); 6247 } 6248 if (bcmp(pd->pd_remote_nodep->fd_node_name.raw_wwn, 6249 wwn.raw_wwn, sizeof (la_wwn_t)) == 0) { 6250 mutex_exit(&pd->pd_mutex); 6251 return (pd); 6252 } 6253 mutex_exit(&pd->pd_mutex); 6254 pd = pd->pd_wwn_hnext; 6255 } 6256 } 6257 /* No match */ 6258 return (NULL); 6259 } 6260 6261 6262 /* 6263 * Count the number of ports on this adapter. 6264 * This routine will walk the port list and count up the number of adapters 6265 * with matching fp_hba_port_attrs.hba_fru_details.high and 6266 * fp_hba_port_attrs.hba_fru_details.low. 6267 * 6268 * port->fp_mutex must not be held. 6269 */ 6270 int 6271 fctl_count_fru_ports(fc_local_port_t *port, int npivflag) 6272 { 6273 fca_hba_fru_details_t *fru; 6274 fc_fca_port_t *fca_port; 6275 fc_local_port_t *tmpPort = NULL; 6276 uint32_t count = 1; 6277 6278 mutex_enter(&fctl_port_lock); 6279 6280 mutex_enter(&port->fp_mutex); 6281 fru = &port->fp_hba_port_attrs.hba_fru_details; 6282 6283 /* Detect FCA drivers that don't support linking HBA ports */ 6284 if (fru->high == 0 && fru->low == 0 && fru->port_index == 0) { 6285 mutex_exit(&port->fp_mutex); 6286 mutex_exit(&fctl_port_lock); 6287 return (1); 6288 } 6289 6290 for (fca_port = fctl_fca_portlist; fca_port != NULL; 6291 fca_port = fca_port->port_next) { 6292 tmpPort = fca_port->port_handle; 6293 if (tmpPort == port) { 6294 continue; 6295 } 6296 mutex_enter(&tmpPort->fp_mutex); 6297 6298 /* 6299 * If an FCA driver returns unique fru->high and fru->low for 6300 * ports on the same card, there is no way for the transport 6301 * layer to determine that the two ports on the same FRU. So, 6302 * the discovery of the ports on a same FRU is limited to what 6303 * the FCA driver can report back. 6304 */ 6305 if (tmpPort->fp_hba_port_attrs.hba_fru_details.high == 6306 fru->high && 6307 tmpPort->fp_hba_port_attrs.hba_fru_details.low == 6308 fru->low) { 6309 /* Now double check driver */ 6310 if (strncmp(port->fp_hba_port_attrs.driver_name, 6311 tmpPort->fp_hba_port_attrs.driver_name, 6312 FCHBA_DRIVER_NAME_LEN) == 0) { 6313 if (!npivflag || 6314 (tmpPort->fp_npiv_type != FC_NPIV_PORT)) { 6315 count++; 6316 } 6317 } /* Else, different FCA driver */ 6318 } /* Else not the same HBA FRU */ 6319 mutex_exit(&tmpPort->fp_mutex); 6320 } 6321 6322 mutex_exit(&port->fp_mutex); 6323 mutex_exit(&fctl_port_lock); 6324 6325 return (count); 6326 } 6327 6328 fc_fca_port_t * 6329 fctl_local_port_list_add(fc_fca_port_t *list, fc_local_port_t *port) 6330 { 6331 fc_fca_port_t *tmp = list, *newentry = NULL; 6332 6333 newentry = kmem_zalloc(sizeof (fc_fca_port_t), KM_NOSLEEP); 6334 if (newentry == NULL) { 6335 return (list); 6336 } 6337 newentry->port_handle = port; 6338 6339 if (tmp == NULL) { 6340 return (newentry); 6341 } 6342 while (tmp->port_next != NULL) tmp = tmp->port_next; 6343 tmp->port_next = newentry; 6344 6345 return (list); 6346 } 6347 6348 void 6349 fctl_local_port_list_free(fc_fca_port_t *list) 6350 { 6351 fc_fca_port_t *tmp = list, *nextentry; 6352 6353 if (tmp == NULL) { 6354 return; 6355 } 6356 6357 while (tmp != NULL) { 6358 nextentry = tmp->port_next; 6359 kmem_free(tmp, sizeof (*tmp)); 6360 tmp = nextentry; 6361 } 6362 } 6363 6364 /* 6365 * Fetch another port on the HBA FRU based on index. 6366 * Returns NULL if index not found. 6367 * 6368 * port->fp_mutex must not be held. 6369 */ 6370 fc_local_port_t * 6371 fctl_get_adapter_port_by_index(fc_local_port_t *port, uint32_t port_index) 6372 { 6373 fca_hba_fru_details_t *fru; 6374 fc_fca_port_t *fca_port; 6375 fc_local_port_t *tmpPort = NULL; 6376 fc_fca_port_t *list = NULL, *tmpEntry; 6377 fc_local_port_t *phyPort, *virPort = NULL; 6378 int index, phyPortNum = 0; 6379 6380 mutex_enter(&fctl_port_lock); 6381 6382 mutex_enter(&port->fp_mutex); 6383 fru = &port->fp_hba_port_attrs.hba_fru_details; 6384 6385 /* Are we looking for this port? */ 6386 if (fru->port_index == port_index) { 6387 mutex_exit(&port->fp_mutex); 6388 mutex_exit(&fctl_port_lock); 6389 return (port); 6390 } 6391 6392 /* Detect FCA drivers that don't support linking HBA ports */ 6393 if (fru->high == 0 && fru->low == 0 && fru->port_index == 0) { 6394 mutex_exit(&port->fp_mutex); 6395 mutex_exit(&fctl_port_lock); 6396 return (NULL); 6397 } 6398 6399 list = fctl_local_port_list_add(list, port); 6400 phyPortNum++; 6401 /* Loop through all known ports */ 6402 for (fca_port = fctl_fca_portlist; fca_port != NULL; 6403 fca_port = fca_port->port_next) { 6404 tmpPort = fca_port->port_handle; 6405 if (tmpPort == port) { 6406 /* Skip the port that was passed in as the argument */ 6407 continue; 6408 } 6409 mutex_enter(&tmpPort->fp_mutex); 6410 6411 /* See if this port is on the same HBA FRU (fast check) */ 6412 if (tmpPort->fp_hba_port_attrs.hba_fru_details.high == 6413 fru->high && 6414 tmpPort->fp_hba_port_attrs.hba_fru_details.low == 6415 fru->low) { 6416 /* Now double check driver (slower check) */ 6417 if (strncmp(port->fp_hba_port_attrs.driver_name, 6418 tmpPort->fp_hba_port_attrs.driver_name, 6419 FCHBA_DRIVER_NAME_LEN) == 0) { 6420 6421 fru = 6422 &tmpPort->fp_hba_port_attrs.hba_fru_details; 6423 /* Check for the matching port_index */ 6424 if ((tmpPort->fp_npiv_type != FC_NPIV_PORT) && 6425 (fru->port_index == port_index)) { 6426 /* Found it! */ 6427 mutex_exit(&tmpPort->fp_mutex); 6428 mutex_exit(&port->fp_mutex); 6429 mutex_exit(&fctl_port_lock); 6430 fctl_local_port_list_free(list); 6431 return (tmpPort); 6432 } 6433 if (tmpPort->fp_npiv_type != FC_NPIV_PORT) { 6434 (void) fctl_local_port_list_add(list, 6435 tmpPort); 6436 phyPortNum++; 6437 } 6438 } /* Else, different FCA driver */ 6439 } /* Else not the same HBA FRU */ 6440 mutex_exit(&tmpPort->fp_mutex); 6441 6442 } 6443 6444 /* scan all physical port on same chip to find virtual port */ 6445 tmpEntry = list; 6446 index = phyPortNum - 1; 6447 virPort = NULL; 6448 while (index < port_index) { 6449 if (tmpEntry == NULL) { 6450 break; 6451 } 6452 if (virPort == NULL) { 6453 phyPort = tmpEntry->port_handle; 6454 virPort = phyPort->fp_port_next; 6455 if (virPort == NULL) { 6456 tmpEntry = tmpEntry->port_next; 6457 continue; 6458 } 6459 } else { 6460 virPort = virPort->fp_port_next; 6461 } 6462 if (virPort == phyPort) { 6463 tmpEntry = tmpEntry->port_next; 6464 virPort = NULL; 6465 } else { 6466 index++; 6467 } 6468 } 6469 mutex_exit(&port->fp_mutex); 6470 mutex_exit(&fctl_port_lock); 6471 6472 fctl_local_port_list_free(list); 6473 if (virPort) { 6474 return (virPort); 6475 } 6476 return (NULL); 6477 } 6478 6479 int 6480 fctl_busy_port(fc_local_port_t *port) 6481 { 6482 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 6483 6484 mutex_enter(&port->fp_mutex); 6485 if (port->fp_soft_state & FP_SOFT_NO_PMCOMP) { 6486 /* 6487 * If fctl_busy_port() is called before we've registered our 6488 * PM components, we return success. We need to be aware of 6489 * this because the caller will eventually call fctl_idle_port. 6490 * This wouldn't be a problem except that if we have 6491 * registered our PM components in the meantime, we will 6492 * then be idling a component that was never busied. PM 6493 * will be very unhappy if we do this. Thus, we keep 6494 * track of this with port->fp_pm_busy_nocomp. 6495 */ 6496 port->fp_pm_busy_nocomp++; 6497 mutex_exit(&port->fp_mutex); 6498 return (0); 6499 } 6500 port->fp_pm_busy++; 6501 mutex_exit(&port->fp_mutex); 6502 6503 if (pm_busy_component(port->fp_port_dip, 6504 FP_PM_COMPONENT) != DDI_SUCCESS) { 6505 mutex_enter(&port->fp_mutex); 6506 port->fp_pm_busy--; 6507 mutex_exit(&port->fp_mutex); 6508 return (ENXIO); 6509 } 6510 6511 mutex_enter(&port->fp_mutex); 6512 if (port->fp_pm_level == FP_PM_PORT_DOWN) { 6513 mutex_exit(&port->fp_mutex); 6514 if (pm_raise_power(port->fp_port_dip, FP_PM_COMPONENT, 6515 FP_PM_PORT_UP) != DDI_SUCCESS) { 6516 6517 mutex_enter(&port->fp_mutex); 6518 port->fp_pm_busy--; 6519 mutex_exit(&port->fp_mutex); 6520 6521 (void) pm_idle_component(port->fp_port_dip, 6522 FP_PM_COMPONENT); 6523 return (EIO); 6524 } 6525 return (0); 6526 } 6527 mutex_exit(&port->fp_mutex); 6528 return (0); 6529 } 6530 6531 void 6532 fctl_idle_port(fc_local_port_t *port) 6533 { 6534 ASSERT(!MUTEX_HELD(&port->fp_mutex)); 6535 6536 mutex_enter(&port->fp_mutex); 6537 6538 /* 6539 * If port->fp_pm_busy_nocomp is > 0, that means somebody had 6540 * called fctl_busy_port prior to us registering our PM components. 6541 * In that case, we just decrement fp_pm_busy_nocomp and return. 6542 */ 6543 6544 if (port->fp_pm_busy_nocomp > 0) { 6545 port->fp_pm_busy_nocomp--; 6546 mutex_exit(&port->fp_mutex); 6547 return; 6548 } 6549 6550 port->fp_pm_busy--; 6551 mutex_exit(&port->fp_mutex); 6552 6553 (void) pm_idle_component(port->fp_port_dip, FP_PM_COMPONENT); 6554 } 6555 6556 /* 6557 * Function: fctl_tc_timer 6558 * 6559 * Description: Resets the value of the timed counter. 6560 * 6561 * Arguments: *tc Timed counter 6562 * 6563 * Return Value: Nothing 6564 * 6565 * Context: Kernel context. 6566 */ 6567 static void 6568 fctl_tc_timer(void *arg) 6569 { 6570 timed_counter_t *tc = (timed_counter_t *)arg; 6571 6572 ASSERT(tc != NULL); 6573 ASSERT(tc->sig == tc); 6574 6575 mutex_enter(&tc->mutex); 6576 if (tc->active) { 6577 tc->active = B_FALSE; 6578 tc->counter = 0; 6579 } 6580 mutex_exit(&tc->mutex); 6581 } 6582 6583 /* 6584 * Function: fctl_tc_constructor 6585 * 6586 * Description: Constructs a timed counter. 6587 * 6588 * Arguments: *tc Address where the timed counter will reside. 6589 * max_value Maximum value the counter is allowed to take. 6590 * timer Number of microseconds after which the counter 6591 * will be reset. The timer is started when the 6592 * value of the counter goes from 0 to 1. 6593 * 6594 * Return Value: Nothing 6595 * 6596 * Context: Kernel context. 6597 */ 6598 void 6599 fctl_tc_constructor(timed_counter_t *tc, uint32_t max_value, clock_t timer) 6600 { 6601 ASSERT(tc != NULL); 6602 ASSERT(tc->sig != tc); 6603 6604 bzero(tc, sizeof (*tc)); 6605 mutex_init(&tc->mutex, NULL, MUTEX_DRIVER, NULL); 6606 tc->timer = drv_usectohz(timer); 6607 tc->active = B_FALSE; 6608 tc->maxed_out = B_FALSE; 6609 tc->max_value = max_value; 6610 tc->sig = tc; 6611 } 6612 6613 /* 6614 * Function: fctl_tc_destructor 6615 * 6616 * Description: Destroyes a timed counter. 6617 * 6618 * Arguments: *tc Timed counter to destroy. 6619 * 6620 * Return Value: Nothing 6621 * 6622 * Context: Kernel context. 6623 */ 6624 void 6625 fctl_tc_destructor(timed_counter_t *tc) 6626 { 6627 ASSERT(tc != NULL); 6628 ASSERT(tc->sig == tc); 6629 ASSERT(!mutex_owned(&tc->mutex)); 6630 6631 mutex_enter(&tc->mutex); 6632 if (tc->active) { 6633 tc->active = B_FALSE; 6634 mutex_exit(&tc->mutex); 6635 (void) untimeout(tc->tid); 6636 mutex_enter(&tc->mutex); 6637 tc->sig = NULL; 6638 } 6639 mutex_exit(&tc->mutex); 6640 mutex_destroy(&tc->mutex); 6641 } 6642 6643 /* 6644 * Function: fctl_tc_increment 6645 * 6646 * Description: Increments a timed counter 6647 * 6648 * Arguments: *tc Timed counter to increment. 6649 * 6650 * Return Value: B_TRUE Counter reached the max value. 6651 * B_FALSE Counter hasn't reached the max value. 6652 * 6653 * Context: Kernel or interrupt context. 6654 */ 6655 boolean_t 6656 fctl_tc_increment(timed_counter_t *tc) 6657 { 6658 ASSERT(tc != NULL); 6659 ASSERT(tc->sig == tc); 6660 6661 mutex_enter(&tc->mutex); 6662 if (!tc->maxed_out) { 6663 /* Hasn't maxed out yet. */ 6664 ++tc->counter; 6665 if (tc->counter >= tc->max_value) { 6666 /* Just maxed out. */ 6667 tc->maxed_out = B_TRUE; 6668 } 6669 if (!tc->active) { 6670 tc->tid = timeout(fctl_tc_timer, tc, tc->timer); 6671 tc->active = B_TRUE; 6672 } 6673 } 6674 mutex_exit(&tc->mutex); 6675 6676 return (tc->maxed_out); 6677 } 6678 6679 /* 6680 * Function: fctl_tc_reset 6681 * 6682 * Description: Resets a timed counter. The caller of this function has to 6683 * to make sure that while in fctl_tc_reset() fctl_tc_increment() 6684 * is not called. 6685 * 6686 * Arguments: *tc Timed counter to reset. 6687 * 6688 * Return Value: 0 Counter reached the max value. 6689 * Not 0 Counter hasn't reached the max value. 6690 * 6691 * Context: Kernel or interrupt context. 6692 */ 6693 void 6694 fctl_tc_reset(timed_counter_t *tc) 6695 { 6696 ASSERT(tc != NULL); 6697 ASSERT(tc->sig == tc); 6698 6699 mutex_enter(&tc->mutex); 6700 tc->counter = 0; 6701 tc->maxed_out = B_FALSE; 6702 if (tc->active) { 6703 tc->active = B_FALSE; 6704 (void) untimeout(tc->tid); 6705 } 6706 mutex_exit(&tc->mutex); 6707 } 6708 6709 void 6710 fc_ulp_log_device_event(opaque_t port_handle, int type) 6711 { 6712 fc_local_port_t *port = port_handle; 6713 nvlist_t *attr_list; 6714 6715 if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, 6716 KM_SLEEP) != DDI_SUCCESS) { 6717 return; 6718 } 6719 6720 if (nvlist_add_uint32(attr_list, "instance", 6721 port->fp_instance) != DDI_SUCCESS) { 6722 goto error; 6723 } 6724 6725 if (nvlist_add_byte_array(attr_list, "port-wwn", 6726 port->fp_service_params.nport_ww_name.raw_wwn, 6727 sizeof (la_wwn_t)) != DDI_SUCCESS) { 6728 goto error; 6729 } 6730 6731 (void) ddi_log_sysevent(port->fp_port_dip, DDI_VENDOR_SUNW, EC_SUNFC, 6732 (type == FC_ULP_DEVICE_ONLINE) ? 6733 ESC_SUNFC_DEVICE_ONLINE : ESC_SUNFC_DEVICE_OFFLINE, 6734 attr_list, NULL, DDI_SLEEP); 6735 nvlist_free(attr_list); 6736 return; 6737 6738 error: 6739 nvlist_free(attr_list); 6740 } 6741