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_sectohz(1));
 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 }