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