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