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