xref: /illumos-gate/usr/src/uts/common/io/scsi/adapters/iscsi/iscsi.c (revision 61dfa5098dc8576d9a5e277deba6df647bb70c06)
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 2000 by Cisco Systems, Inc.  All rights reserved.
23  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
25  * Copyright 2019 Joshua M. Clulow <josh@sysmgr.org>
26  *
27  * iSCSI Software Initiator
28  */
29 
30 /*
31  * Framework interface routines for iSCSI
32  */
33 
34 #include "iscsi.h"				/* main header */
35 #include <sys/iscsi_protocol.h>	/* protocol structs */
36 #include <sys/scsi/adapters/iscsi_if.h>		/* ioctl interfaces */
37 #include "iscsi_targetparam.h"
38 #include "persistent.h"
39 #include <sys/scsi/adapters/iscsi_door.h>
40 #include <sys/dlpi.h>
41 #include <sys/utsname.h>
42 #include "isns_client.h"
43 #include "isns_protocol.h"
44 #include <sys/bootprops.h>
45 #include <sys/types.h>
46 #include <sys/bootconf.h>
47 
48 #define	ISCSI_NAME_VERSION	"iSCSI Initiator v-1.55"
49 
50 #define	MAX_GET_NAME_SIZE	1024
51 #define	MAX_NAME_PROP_SIZE	256
52 #define	UNDEFINED		-1
53 #define	ISCSI_DISC_DELAY	2	/* seconds */
54 
55 /*
56  * +--------------------------------------------------------------------+
57  * | iscsi globals                                                      |
58  * +--------------------------------------------------------------------+
59  */
60 void		*iscsi_state;
61 kmutex_t	iscsi_oid_mutex;
62 uint32_t	iscsi_oid;
63 int		iscsi_nop_delay		= ISCSI_DEFAULT_NOP_DELAY;
64 int		iscsi_rx_window		= ISCSI_DEFAULT_RX_WINDOW;
65 int		iscsi_rx_max_window	= ISCSI_DEFAULT_RX_MAX_WINDOW;
66 boolean_t	iscsi_logging		= B_FALSE;
67 
68 extern ib_boot_prop_t	*iscsiboot_prop;
69 extern int		modrootloaded;
70 extern struct bootobj	rootfs;
71 
72 /*
73  * +--------------------------------------------------------------------+
74  * | iscsi.c prototypes							|
75  * +--------------------------------------------------------------------+
76  */
77 static int iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
78     void *arg, void **result);
79 static int iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
80 static int iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
81 
82 /* scsi_tran prototypes */
83 static int iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
84     scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
85 static int iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ());
86 static struct scsi_pkt *iscsi_tran_init_pkt(struct scsi_address *ap,
87     struct scsi_pkt *pkt, struct buf *bp, int cmdlen, int statuslen,
88     int tgtlen, int flags, int (*callback) (), caddr_t arg);
89 static void iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip,
90     scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
91 static int iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt);
92 static int iscsi_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt);
93 static int iscsi_tran_reset(struct scsi_address *ap, int level);
94 static int iscsi_tran_getcap(struct scsi_address *ap, char *cap, int whom);
95 static int iscsi_tran_setcap(struct scsi_address *ap, char *cap,
96     int value, int whom);
97 static void iscsi_tran_destroy_pkt(struct scsi_address *ap,
98     struct scsi_pkt *pkt);
99 static void iscsi_tran_dmafree(struct scsi_address *ap,
100     struct scsi_pkt *pkt);
101 static void iscsi_tran_sync_pkt(struct scsi_address *ap,
102     struct scsi_pkt *pkt);
103 static void iscsi_tran_sync_pkt(struct scsi_address *ap,
104     struct scsi_pkt *pkt);
105 static int iscsi_tran_reset_notify(struct scsi_address *ap, int flag,
106     void (*callback) (caddr_t), caddr_t arg);
107 static int iscsi_tran_bus_config(dev_info_t *parent, uint_t flags,
108     ddi_bus_config_op_t op, void *arg, dev_info_t **childp);
109 static int iscsi_tran_bus_unconfig(dev_info_t *parent, uint_t flags,
110     ddi_bus_config_op_t op, void *arg);
111 static int iscsi_tran_get_name(struct scsi_device *sd, char *name, int len);
112 static int iscsi_tran_get_bus_addr(struct scsi_device *sd, char *name, int len);
113 
114 /* bus_ops prototypes */
115 /* LINTED E_STATIC_UNUSED */
116 static ddi_intrspec_t iscsi_get_intrspec(dev_info_t *dip, dev_info_t *rdip,
117     uint_t inumber);
118 /* LINTED E_STATIC_UNUSED */
119 static int iscsi_add_intrspec(dev_info_t *dip, dev_info_t *rdip,
120     ddi_intrspec_t intrspec, ddi_iblock_cookie_t *iblock_cookiep,
121     ddi_idevice_cookie_t *idevice_cookiep, uint_t (*int_handler)(caddr_t
122     int_handler_arg), caddr_t int_handler_arg, int kind);
123 /* LINTED E_STATIC_UNUSED */
124 static void iscsi_remove_intrspec(dev_info_t *dip, dev_info_t *rdip,
125     ddi_intrspec_t intrspec, ddi_iblock_cookie_t iblock_cookie);
126 /* LINTED E_STATIC_UNUSED */
127 static int iscsi_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop,
128     void *arg, void *result);
129 
130 /* cb_ops prototypes */
131 static int iscsi_open(dev_t *devp, int flags, int otyp, cred_t *credp);
132 static int iscsi_close(dev_t dev, int flag, int otyp, cred_t *credp);
133 static int iscsi_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
134     cred_t *credp, int *rvalp);
135 
136 int iscsi_get_persisted_param(uchar_t *name,
137     iscsi_param_get_t *ipgp,
138     iscsi_login_params_t *params);
139 static void iscsi_override_target_default(iscsi_hba_t *ihp,
140     iscsi_param_get_t *ipg);
141 
142 /* scsi_tran helpers */
143 static int iscsi_virt_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
144     scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
145 static int iscsi_phys_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
146     scsi_hba_tran_t *hba_tran, struct scsi_device *sd);
147 static int iscsi_i_commoncap(struct scsi_address *ap, char *cap,
148     int val, int lunonly, int doset);
149 static void iscsi_get_name_to_iqn(char *name, int name_max_len);
150 static void iscsi_get_name_from_iqn(char *name, int name_max_len);
151 static boolean_t iscsi_cmp_boot_sess_oid(iscsi_hba_t *ihp, uint32_t oid);
152 
153 /* iscsi initiator service helpers */
154 static boolean_t iscsi_enter_service_zone(iscsi_hba_t *ihp, uint32_t status);
155 static void iscsi_exit_service_zone(iscsi_hba_t *ihp, uint32_t status);
156 static void iscsi_check_miniroot(iscsi_hba_t *ihp);
157 static void iscsi_get_tunable_default(iscsi_tunable_object_t *param);
158 static int iscsi_get_persisted_tunable_param(uchar_t *name,
159     iscsi_tunable_object_t *tpsg);
160 static void iscsi_set_default_tunable_params(iscsi_tunable_params_t *params);
161 
162 /* struct helpers prototypes */
163 
164 /*
165  * At this point this driver doesn't need this structure because nothing
166  * is done during the open, close or ioctl. Code put in place because
167  * some admin related work might be done in the ioctl routine.
168  */
169 static struct cb_ops iscsi_cb_ops = {
170 	iscsi_open,			/* open */
171 	iscsi_close,			/* close */
172 	nodev,				/* strategy */
173 	nodev,				/* print */
174 	nodev,				/* dump */
175 	nodev,				/* read */
176 	nodev,				/* write */
177 	iscsi_ioctl,			/* ioctl */
178 	nodev,				/* devmap */
179 	nodev,				/* mmap */
180 	nodev,				/* segmap */
181 	nochpoll,			/* poll */
182 	ddi_prop_op,			/* prop_op */
183 	NULL,				/* streamtab */
184 	D_NEW | D_MP | D_HOTPLUG,	/* flags */
185 	CB_REV,				/* cb_rev */
186 	nodev,				/* aread */
187 	nodev,				/* awrite */
188 };
189 
190 static struct dev_ops iscsi_dev_ops = {
191 	DEVO_REV,		/* devo_rev */
192 	0,			/* refcnt */
193 	iscsi_getinfo,		/* getinfo */
194 	nulldev,		/* identify */
195 	nulldev,		/* probe */
196 	iscsi_attach,		/* attach */
197 	iscsi_detach,		/* detach */
198 	nodev,			/* reset */
199 	&iscsi_cb_ops,		/* driver operations */
200 	NULL,			/* bus ops */
201 	NULL,			/* power management */
202 	ddi_quiesce_not_needed,	/* quiesce */
203 };
204 
205 static struct modldrv modldrv = {
206 	&mod_driverops,		/* drv_modops */
207 	ISCSI_NAME_VERSION,	/* drv_linkinfo */
208 	&iscsi_dev_ops		/* drv_dev_ops */
209 };
210 
211 static struct modlinkage modlinkage = {
212 	MODREV_1,		/* ml_rev */
213 	&modldrv,		/* ml_linkage[] */
214 	NULL			/* NULL termination */
215 };
216 
217 /*
218  * This structure is bogus. scsi_hba_attach_setup() requires, as in the kernel
219  * will panic if you don't pass this in to the routine, this information.
220  * Need to determine what the actual impact to the system is by providing
221  * this information if any. Since dma allocation is done in pkt_init it may
222  * not have any impact. These values are straight from the Writing Device
223  * Driver manual.
224  */
225 static ddi_dma_attr_t iscsi_dma_attr = {
226 	DMA_ATTR_V0,	/* ddi_dma_attr version */
227 	0,		/* low address */
228 	0xffffffff,	/* high address */
229 	0x00ffffff,	/* counter upper bound */
230 	1,		/* alignment requirements */
231 	0x3f,		/* burst sizes */
232 	1,		/* minimum DMA access */
233 	0xffffffff,	/* maximum DMA access */
234 	(1 << 24) - 1,	/* segment boundary restrictions */
235 	1,		/* scater/gather list length */
236 	512,		/* device granularity */
237 	0		/* DMA flags */
238 };
239 
240 /*
241  * _init - General driver init entry
242  */
243 int
_init(void)244 _init(void)
245 {
246 	int rval = 0;
247 
248 	iscsi_net_init();
249 
250 	mutex_init(&iscsi_oid_mutex, NULL, MUTEX_DRIVER, NULL);
251 	iscsi_oid = ISCSI_INITIATOR_OID;
252 
253 	/*
254 	 * Set up the soft state structures. If this driver is actually
255 	 * being attached to the system then we'll have at least one
256 	 * HBA/NIC used.
257 	 */
258 	rval = ddi_soft_state_init(&iscsi_state,
259 	    sizeof (iscsi_hba_t), 1);
260 	if (rval != 0) {
261 		iscsi_net_fini();
262 		goto init_done;
263 	}
264 
265 	rval = scsi_hba_init(&modlinkage);
266 	if (rval != 0) {
267 		ddi_soft_state_fini(&iscsi_state);
268 		iscsi_net_fini();
269 		goto init_done;
270 	}
271 
272 	rval = mod_install(&modlinkage);
273 	if (rval != 0) {
274 		ddi_soft_state_fini(&iscsi_state);
275 		scsi_hba_fini(&modlinkage);
276 		iscsi_net_fini();
277 		goto init_done;
278 	}
279 	(void) iscsi_door_ini();
280 
281 init_done:
282 	return (rval);
283 }
284 
285 /*
286  * _fini - General driver destructor entry
287  */
288 int
_fini(void)289 _fini(void)
290 {
291 	int rval = 0;
292 
293 	rval = mod_remove(&modlinkage);
294 	if (rval == 0) {
295 		scsi_hba_fini(&modlinkage);
296 		ddi_soft_state_fini(&iscsi_state);
297 		mutex_destroy(&iscsi_oid_mutex);
298 		(void) iscsi_door_term();
299 		iscsi_net_fini();
300 	}
301 	return (rval);
302 }
303 
304 /*
305  * _info - General driver info entry
306  */
307 int
_info(struct modinfo * mp)308 _info(struct modinfo *mp)
309 {
310 	int rval = 0;
311 
312 	rval = mod_info(&modlinkage, mp);
313 
314 	return (rval);
315 }
316 
317 
318 /*
319  * +--------------------------------------------------------------------+
320  * | Start of dev_ops routines					  |
321  * +--------------------------------------------------------------------+
322  */
323 
324 /*
325  * iscsi_getinfo - returns general driver information
326  */
327 /* ARGSUSED */
328 static int
iscsi_getinfo(dev_info_t * dip,ddi_info_cmd_t infocmd,void * arg,void ** result)329 iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd,
330     void *arg, void **result)
331 {
332 	int		rval		= DDI_SUCCESS;
333 	int		instance	= getminor((dev_t)arg);
334 	iscsi_hba_t	*ip;
335 
336 	switch (infocmd) {
337 	case DDI_INFO_DEVT2DEVINFO:
338 		if ((ip = ddi_get_soft_state(iscsi_state, instance)) == NULL) {
339 			return (DDI_FAILURE);
340 		}
341 		*result = ip->hba_dip;
342 		if (ip->hba_dip == NULL)
343 			rval = DDI_FAILURE;
344 		else
345 			rval = DDI_SUCCESS;
346 		break;
347 
348 	case DDI_INFO_DEVT2INSTANCE:
349 		*result = (void *)(uintptr_t)instance;
350 		rval = DDI_SUCCESS;
351 		break;
352 
353 	default:
354 		rval = DDI_FAILURE;
355 		break;
356 	}
357 	return (rval);
358 }
359 
360 
361 /*
362  * iscsi_attach -- Attach instance of an iSCSI HBA.  We
363  * will attempt to create our HBA and register it with
364  * scsi_vhci.  If it's not possible to create the HBA
365  * or register with vhci we will fail the attach.
366  */
367 static int
iscsi_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)368 iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
369 {
370 	int			instance	= ddi_get_instance(dip);
371 	iscsi_hba_t		*ihp		= NULL;
372 	scsi_hba_tran_t		*tran		= NULL;
373 	char			init_port_name[MAX_NAME_PROP_SIZE];
374 
375 	if (cmd == DDI_RESUME) {
376 		return (DDI_SUCCESS);
377 	} else if (cmd != DDI_ATTACH) {
378 		return (DDI_FAILURE);
379 	}
380 
381 	if (!modrootloaded && iscsiboot_prop == NULL) {
382 		/*
383 		 * The root file system has not yet been mounted, and we're not
384 		 * trying to boot from an iSCSI device.  Fail to attach now so
385 		 * that we can retry after root has been mounted.
386 		 */
387 		return (DDI_FAILURE);
388 	}
389 
390 	/* create iSCSI HBA devctl device node */
391 	if (ddi_create_minor_node(dip, ISCSI_DEVCTL, S_IFCHR, 0,
392 	    DDI_PSEUDO, 0) != DDI_SUCCESS) {
393 		goto iscsi_attach_failed3;
394 	}
395 
396 	/* allocate HBA soft state */
397 	if (ddi_soft_state_zalloc(iscsi_state, instance) !=
398 	    DDI_SUCCESS) {
399 		ddi_remove_minor_node(dip, NULL);
400 		goto iscsi_attach_failed3;
401 	}
402 
403 	/* get reference to soft state */
404 	if ((ihp = (iscsi_hba_t *)ddi_get_soft_state(
405 	    iscsi_state, instance)) == NULL) {
406 		ddi_remove_minor_node(dip, NULL);
407 		ddi_soft_state_free(iscsi_state, instance);
408 		goto iscsi_attach_failed3;
409 	}
410 
411 	/* init HBA mutex used to protect discovery events */
412 	mutex_init(&ihp->hba_discovery_events_mutex, NULL,
413 	    MUTEX_DRIVER, NULL);
414 
415 	VERIFY0(ldi_ident_from_dip(dip, &ihp->hba_li));
416 
417 	/* init HBA mutex used to protect service status */
418 	mutex_init(&ihp->hba_service_lock, NULL,
419 	    MUTEX_DRIVER, NULL);
420 	cv_init(&ihp->hba_service_cv, NULL, CV_DRIVER, NULL);
421 
422 	/*
423 	 * init SendTargets semaphore that is used to allow
424 	 * only one operation at a time
425 	 */
426 	sema_init(&ihp->hba_sendtgts_semaphore, 1, NULL,
427 	    SEMA_DRIVER, NULL);
428 
429 	ihp->hba_sess_list = NULL;
430 	rw_init(&ihp->hba_sess_list_rwlock, NULL,
431 	    RW_DRIVER, NULL);
432 
433 	/* allocate scsi_hba_tran */
434 	if ((tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP))
435 	    == NULL) {
436 		ddi_remove_minor_node(dip, NULL);
437 		goto iscsi_attach_failed2;
438 	}
439 
440 	/* soft state setup */
441 	ihp->hba_sig	= ISCSI_SIG_HBA;
442 	ihp->hba_tran	= tran;
443 	ihp->hba_dip	= dip;
444 	if (iscsiboot_prop == NULL) {
445 		ihp->hba_service_status =
446 		    ISCSI_SERVICE_DISABLED;
447 		ihp->hba_service_status_overwrite = B_FALSE;
448 	} else {
449 		ihp->hba_service_status =
450 		    ISCSI_SERVICE_ENABLED;
451 		ihp->hba_service_status_overwrite = B_TRUE;
452 	}
453 	ihp->hba_service_client_count = 0;
454 
455 	mutex_enter(&iscsi_oid_mutex);
456 	ihp->hba_oid		  = iscsi_oid++;
457 	mutex_exit(&iscsi_oid_mutex);
458 
459 	ihp->hba_name[0]	  = '\0';
460 	ihp->hba_name_length	  = 0;
461 	ihp->hba_alias_length	  = 0;
462 	ihp->hba_alias[0]	  = '\0';
463 
464 	iscsi_net->tweaks.rcvbuf = ddi_prop_get_int(
465 	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-rcvbuf",
466 	    ISCSI_SOCKET_RCVBUF_SIZE);
467 
468 	iscsi_net->tweaks.sndbuf = ddi_prop_get_int(
469 	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-sndbuf",
470 	    ISCSI_SOCKET_SNDBUF_SIZE);
471 
472 	iscsi_net->tweaks.nodelay = ddi_prop_get_int(
473 	    DDI_DEV_T_ANY, ihp->hba_dip, 0, "tcp-nodelay",
474 	    ISCSI_TCP_NODELAY_DEFAULT);
475 
476 	iscsi_net->tweaks.conn_notify_threshold =
477 	    ddi_prop_get_int(DDI_DEV_T_ANY,
478 	    ihp->hba_dip, 0, "tcp-conn-notify-threshold",
479 	    ISCSI_TCP_CNOTIFY_THRESHOLD_DEFAULT);
480 
481 	iscsi_net->tweaks.conn_abort_threshold =
482 	    ddi_prop_get_int(DDI_DEV_T_ANY, ihp->hba_dip,
483 	    0, "tcp-conn-abort-threshold",
484 	    ISCSI_TCP_CABORT_THRESHOLD_DEFAULT);
485 
486 	iscsi_net->tweaks.abort_threshold = ddi_prop_get_int(
487 	    DDI_DEV_T_ANY, ihp->hba_dip, 0,
488 	    "tcp-abort-threshold",
489 	    ISCSI_TCP_ABORT_THRESHOLD_DEFAULT);
490 
491 	ihp->hba_config_storm_delay = ddi_prop_get_int(
492 	    DDI_DEV_T_ANY, ihp->hba_dip, 0,
493 	    "config-storm-delay",
494 	    ISCSI_CONFIG_STORM_DELAY_DEFAULT);
495 
496 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
497 	    "so-rcvbuf", iscsi_net->tweaks.rcvbuf);
498 
499 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
500 	    "so-sndbuf", iscsi_net->tweaks.sndbuf);
501 
502 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
503 	    "tcp-nodelay", iscsi_net->tweaks.nodelay);
504 
505 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
506 	    "tcp-conn-notify-threshold",
507 	    iscsi_net->tweaks.conn_notify_threshold);
508 
509 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
510 	    "tcp-conn-abort-threshold",
511 	    iscsi_net->tweaks.conn_abort_threshold);
512 
513 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
514 	    "tcp-abort-threshold",
515 	    iscsi_net->tweaks.abort_threshold);
516 
517 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip,
518 	    "config-storm-delay",
519 	    ihp->hba_config_storm_delay);
520 
521 	/* setup hba defaults */
522 	iscsi_set_default_login_params(&ihp->hba_params);
523 	iscsi_set_default_tunable_params(
524 	    &ihp->hba_tunable_params);
525 
526 	/* setup minimal initiator params */
527 	iscsid_set_default_initiator_node_settings(ihp, B_TRUE);
528 
529 	/* hba set up */
530 	tran->tran_hba_private  = ihp;
531 	tran->tran_tgt_private  = NULL;
532 	tran->tran_tgt_init	= iscsi_tran_lun_init;
533 	tran->tran_tgt_probe	= iscsi_tran_lun_probe;
534 	tran->tran_tgt_free	= iscsi_tran_lun_free;
535 	tran->tran_start	= iscsi_tran_start;
536 	tran->tran_abort	= iscsi_tran_abort;
537 	tran->tran_reset	= iscsi_tran_reset;
538 	tran->tran_getcap	= iscsi_tran_getcap;
539 	tran->tran_setcap	= iscsi_tran_setcap;
540 	tran->tran_init_pkt	= iscsi_tran_init_pkt;
541 	tran->tran_destroy_pkt	= iscsi_tran_destroy_pkt;
542 	tran->tran_dmafree	= iscsi_tran_dmafree;
543 	tran->tran_sync_pkt	= iscsi_tran_sync_pkt;
544 	tran->tran_reset_notify	= iscsi_tran_reset_notify;
545 	tran->tran_bus_config	= iscsi_tran_bus_config;
546 	tran->tran_bus_unconfig	= iscsi_tran_bus_unconfig;
547 
548 	tran->tran_get_name	= iscsi_tran_get_name;
549 	tran->tran_get_bus_addr	= iscsi_tran_get_bus_addr;
550 	tran->tran_interconnect_type = INTERCONNECT_ISCSI;
551 
552 	/* register scsi hba with scsa */
553 	if (scsi_hba_attach_setup(dip, &iscsi_dma_attr,
554 	    tran, SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) {
555 		goto iscsi_attach_failed1;
556 	}
557 
558 	/* register scsi hba with mdi (MPxIO/vhci) */
559 	if (mdi_phci_register(MDI_HCI_CLASS_SCSI, dip, 0) !=
560 	    MDI_SUCCESS) {
561 		ihp->hba_mpxio_enabled = B_FALSE;
562 	} else {
563 		ihp->hba_mpxio_enabled = B_TRUE;
564 	}
565 
566 	(void) iscsi_hba_kstat_init(ihp);
567 
568 	/* Initialize targetparam list */
569 	iscsi_targetparam_init();
570 
571 	/* Initialize ISID */
572 	ihp->hba_isid[0] = ISCSI_SUN_ISID_0;
573 	ihp->hba_isid[1] = ISCSI_SUN_ISID_1;
574 	ihp->hba_isid[2] = ISCSI_SUN_ISID_2;
575 	ihp->hba_isid[3] = ISCSI_SUN_ISID_3;
576 	ihp->hba_isid[4] = ISCSI_SUN_ISID_4;
577 	ihp->hba_isid[5] = ISCSI_SUN_ISID_5;
578 
579 	/* Setup iSNS transport services and client */
580 	isns_client_init();
581 
582 	/*
583 	 * initialize persistent store,
584 	 * or boot target info in case of iscsi boot
585 	 */
586 	ihp->hba_persistent_loaded = B_FALSE;
587 	if (iscsid_init(ihp) == B_FALSE) {
588 		goto iscsi_attach_failed0;
589 	}
590 
591 	/* Setup init_port_name for MPAPI */
592 	(void) snprintf(init_port_name, MAX_NAME_PROP_SIZE,
593 	    "%s,%02x%02x%02x%02x%02x%02x",
594 	    (char *)ihp->hba_name, ihp->hba_isid[0],
595 	    ihp->hba_isid[1], ihp->hba_isid[2],
596 	    ihp->hba_isid[3], ihp->hba_isid[4],
597 	    ihp->hba_isid[5]);
598 
599 	if (ddi_prop_update_string(DDI_DEV_T_NONE, dip,
600 	    SCSI_ADDR_PROP_INITIATOR_PORT, init_port_name) !=
601 	    DDI_PROP_SUCCESS) {
602 		cmn_err(CE_WARN, "iscsi_attach: Creating "
603 		    SCSI_ADDR_PROP_INITIATOR_PORT
604 		    " property on iSCSI "
605 		    "HBA(%s) with dip(%d) Failed",
606 		    (char *)ihp->hba_name,
607 		    ddi_get_instance(dip));
608 	}
609 
610 	ddi_report_dev(dip);
611 	return (DDI_SUCCESS);
612 
613 iscsi_attach_failed0:
614 	isns_client_cleanup();
615 	if (ihp->stats.ks) {
616 		(void) iscsi_hba_kstat_term(ihp);
617 	}
618 	if (ihp->hba_mpxio_enabled == B_TRUE) {
619 		(void) mdi_phci_unregister(dip, 0);
620 	}
621 	(void) scsi_hba_detach(ihp->hba_dip);
622 iscsi_attach_failed1:
623 	ddi_remove_minor_node(dip, NULL);
624 	ddi_prop_remove_all(ihp->hba_dip);
625 	scsi_hba_tran_free(tran);
626 iscsi_attach_failed2:
627 	cv_destroy(&ihp->hba_service_cv);
628 	mutex_destroy(&ihp->hba_service_lock);
629 	mutex_destroy(&ihp->hba_discovery_events_mutex);
630 	sema_destroy(&ihp->hba_sendtgts_semaphore);
631 	rw_destroy(&ihp->hba_sess_list_rwlock);
632 	ddi_soft_state_free(iscsi_state, instance);
633 iscsi_attach_failed3:
634 	cmn_err(CE_WARN, "iscsi driver unable to attach "
635 	    "hba instance %d", instance);
636 	return (DDI_FAILURE);
637 }
638 
639 /*
640  * iscsi_detach - called on unload of hba instance
641  */
642 static int
iscsi_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)643 iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
644 {
645 	int			rval		= DDI_SUCCESS;
646 	scsi_hba_tran_t		*tran		= NULL;
647 	iscsi_hba_t		*ihp		= NULL;
648 	iscsi_hba_t		*ihp_check	= NULL;
649 	int			instance;
650 	char			*init_node_name;
651 
652 	instance = ddi_get_instance(dip);
653 
654 	switch (cmd) {
655 	case DDI_DETACH:
656 		if (!(tran = (scsi_hba_tran_t *)ddi_get_driver_private(dip))) {
657 			rval = DDI_SUCCESS;
658 			break;
659 		}
660 
661 		if ((ihp = (iscsi_hba_t *)tran->tran_hba_private) == NULL) {
662 			rval =  DDI_FAILURE;
663 			break;
664 		}
665 
666 		/*
667 		 * Validate that what is stored by the DDI framework is still
668 		 * the same state structure referenced by the SCSI framework
669 		 */
670 		ihp_check = ddi_get_soft_state(iscsi_state, instance);
671 		if (ihp_check != ihp) {
672 			rval = DDI_FAILURE;
673 			break;
674 		}
675 
676 		/* If a session exists we can't safely detach */
677 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
678 		if (ihp->hba_sess_list != NULL) {
679 			rw_exit(&ihp->hba_sess_list_rwlock);
680 			rval = DDI_FAILURE;
681 			break;
682 		}
683 		rw_exit(&ihp->hba_sess_list_rwlock);
684 
685 		/* Disable all discovery services */
686 		if (iscsid_disable_discovery(ihp,
687 		    ISCSI_ALL_DISCOVERY_METHODS) == B_FALSE) {
688 			/* Disable failed.  Fail detach */
689 			rval = DDI_FAILURE;
690 			break;
691 		}
692 
693 		/* Deregister from iSNS server(s). */
694 		init_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
695 		if (persistent_initiator_name_get(init_node_name,
696 		    ISCSI_MAX_NAME_LEN) == B_TRUE) {
697 			if (strlen(init_node_name) > 0) {
698 				(void) isns_dereg(ihp->hba_isid,
699 				    (uint8_t *)init_node_name);
700 			}
701 		}
702 		kmem_free(init_node_name, ISCSI_MAX_NAME_LEN);
703 		init_node_name = NULL;
704 
705 		/* Cleanup iSNS Client */
706 		isns_client_cleanup();
707 
708 		iscsi_targetparam_cleanup();
709 
710 		/* Cleanup iscsid resources */
711 		iscsid_fini();
712 
713 		if (rval != DDI_SUCCESS) {
714 			break;
715 		}
716 		/* kstat hba. destroy */
717 		KSTAT_DEC_HBA_CNTR_SESS(ihp);
718 
719 		if (ihp->hba_mpxio_enabled == B_TRUE) {
720 			(void) mdi_phci_unregister(dip, 0);
721 		}
722 		ddi_remove_minor_node(dip, NULL);
723 
724 		ddi_prop_remove_all(ihp->hba_dip);
725 
726 		ldi_ident_release(ihp->hba_li);
727 
728 		cv_destroy(&ihp->hba_service_cv);
729 		mutex_destroy(&ihp->hba_service_lock);
730 		mutex_destroy(&ihp->hba_discovery_events_mutex);
731 		rw_destroy(&ihp->hba_sess_list_rwlock);
732 		(void) iscsi_hba_kstat_term(ihp);
733 
734 		(void) scsi_hba_detach(dip);
735 		if (tran != NULL) {
736 			scsi_hba_tran_free(tran);
737 		}
738 		ddi_soft_state_free(iscsi_state, instance);
739 		break;
740 	default:
741 		break;
742 	}
743 
744 	if (rval != DDI_SUCCESS) {
745 		cmn_err(CE_WARN, "iscsi driver unable to "
746 		    "detach hba instance %d", instance);
747 	}
748 
749 	return (rval);
750 }
751 
752 /*
753  * +--------------------------------------------------------------------+
754  * | End of dev_ops routines						|
755  * +--------------------------------------------------------------------+
756  */
757 
758 /*
759  * +--------------------------------------------------------------------+
760  * | scsi_tran(9E) routines						|
761  * +--------------------------------------------------------------------+
762  */
763 
764 /*
765  * iscsi_tran_lun_init - Find target device based on SCSI device
766  * Based on the information given (SCSI device, target dev_info) find
767  * the target iSCSI device and put a pointer to that information in
768  * the scsi_hba_tran_t structure.
769  */
770 static int
iscsi_tran_lun_init(dev_info_t * hba_dip,dev_info_t * lun_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)771 iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
772     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
773 {
774 	int		rval	= 0;
775 	int		type	= 0;
776 
777 	ASSERT(hba_tran->tran_hba_private != NULL);
778 
779 	/*
780 	 * Child node is getting initialized.  Look at the mpxio component
781 	 * type on the child device to see if this device is mpxio managed
782 	 * or not.
783 	 */
784 	type = mdi_get_component_type(lun_dip);
785 	if (type != MDI_COMPONENT_CLIENT) {
786 		rval = iscsi_phys_lun_init(hba_dip, lun_dip, hba_tran, sd);
787 	} else {
788 		rval = iscsi_virt_lun_init(hba_dip, lun_dip, hba_tran, sd);
789 	}
790 
791 	return (rval);
792 }
793 
794 /*
795  * iscsi_tran_lun_probe - This function didn't need to be implemented.
796  * We could have left NULL in the tran table.  Since this isn't a
797  * performance path this seems safe.  We are just wrappering the
798  * function so we can see the call go through if we have debugging
799  * enabled.
800  */
801 static int
iscsi_tran_lun_probe(struct scsi_device * sd,int (* callback)())802 iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ())
803 {
804 	int rval = 0;
805 
806 	rval = scsi_hba_probe(sd, callback);
807 
808 	return (rval);
809 }
810 
811 /*
812  * iscsi_init_pkt - Allocate SCSI packet and fill in required info.
813  */
814 /* ARGSUSED */
815 static struct scsi_pkt *
iscsi_tran_init_pkt(struct scsi_address * ap,struct scsi_pkt * pkt,struct buf * bp,int cmdlen,int statuslen,int tgtlen,int flags,int (* callback)(),caddr_t arg)816 iscsi_tran_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
817     struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
818     int (*callback) (), caddr_t arg)
819 {
820 	iscsi_lun_t *ilp;
821 	iscsi_cmd_t *icmdp;
822 
823 	ASSERT(ap != NULL);
824 	ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);
825 
826 	/*
827 	 * The software stack doesn't have DMA which means the iSCSI
828 	 * protocol layer will be doing a bcopy from bp to outgoing
829 	 * streams buffers. Make sure that the buffer is mapped in
830 	 * so that the copy won't panic the system.
831 	 */
832 	if (bp && (bp->b_bcount != 0) &&
833 	    bp_mapin_common(bp, (callback == NULL_FUNC) ?
834 	    VM_NOSLEEP : VM_SLEEP) == NULL) {
835 		return (NULL);
836 	}
837 
838 	ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private;
839 	ASSERT(ilp != NULL);
840 
841 	if (pkt == NULL) {
842 		pkt = scsi_hba_pkt_alloc(ilp->lun_sess->sess_hba->hba_dip,
843 		    ap, cmdlen, statuslen, tgtlen, sizeof (iscsi_cmd_t),
844 		    callback, arg);
845 		if (pkt == NULL) {
846 			return (NULL);
847 		}
848 		icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private;
849 		icmdp->cmd_sig			= ISCSI_SIG_CMD;
850 		icmdp->cmd_state		= ISCSI_CMD_STATE_FREE;
851 		icmdp->cmd_lun			= ilp;
852 		iscsi_lun_hold(ilp);
853 		icmdp->cmd_type			= ISCSI_CMD_TYPE_SCSI;
854 		/* add the report lun addressing type on to the lun */
855 		icmdp->cmd_un.scsi.lun		= ilp->lun_addr_type << 14;
856 		icmdp->cmd_un.scsi.lun		= icmdp->cmd_un.scsi.lun |
857 		    ilp->lun_num;
858 		icmdp->cmd_un.scsi.pkt		= pkt;
859 		icmdp->cmd_un.scsi.bp		= bp;
860 		icmdp->cmd_un.scsi.cmdlen	= cmdlen;
861 		icmdp->cmd_un.scsi.statuslen	= statuslen;
862 		icmdp->cmd_crc_error_seen	= B_FALSE;
863 		icmdp->cmd_misc_flags		= 0;
864 		if (flags & PKT_XARQ) {
865 			icmdp->cmd_misc_flags |= ISCSI_CMD_MISCFLAG_XARQ;
866 		}
867 
868 
869 		idm_sm_audit_init(&icmdp->cmd_state_audit);
870 
871 		mutex_init(&icmdp->cmd_mutex, NULL, MUTEX_DRIVER, NULL);
872 		cv_init(&icmdp->cmd_completion, NULL, CV_DRIVER, NULL);
873 
874 		pkt->pkt_address		= *ap;
875 		pkt->pkt_comp			= (void (*)())NULL;
876 		pkt->pkt_flags			= 0;
877 		pkt->pkt_time			= 0;
878 		pkt->pkt_resid			= 0;
879 		pkt->pkt_statistics		= 0;
880 		pkt->pkt_reason			= 0;
881 	}
882 	return (pkt);
883 }
884 
885 /*
886  * iscsi_tran_lun_free - Free a SCSI LUN
887  */
888 static void
iscsi_tran_lun_free(dev_info_t * hba_dip,dev_info_t * lun_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)889 iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip,
890     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
891 {
892 	iscsi_lun_t *ilp = NULL;
893 
894 	ASSERT(hba_dip != NULL);
895 	ASSERT(lun_dip != NULL);
896 	ASSERT(hba_tran != NULL);
897 	ASSERT(sd != NULL);
898 	ilp = (iscsi_lun_t *)hba_tran->tran_tgt_private;
899 	ASSERT(ilp != NULL);
900 
901 	(void) mdi_prop_remove(ilp->lun_pip, NULL);
902 }
903 
904 /*
905  * iscsi_start -- Start a SCSI transaction based on the packet
906  * This will attempt to add the icmdp to the pending queue
907  * for the connection and kick the queue.  If the enqueue
908  * fails that means the queue is full.
909  */
910 static int
iscsi_tran_start(struct scsi_address * ap,struct scsi_pkt * pkt)911 iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt)
912 {
913 	iscsi_lun_t	*ilp		= NULL;
914 	iscsi_sess_t	*isp		= NULL;
915 	iscsi_cmd_t	*icmdp		= NULL;
916 	uint_t		flags;
917 
918 	ASSERT(ap != NULL);
919 	ASSERT(pkt != NULL);
920 	ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private;
921 	isp = (iscsi_sess_t *)ilp->lun_sess;
922 	icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private;
923 	flags = pkt->pkt_flags;
924 	ASSERT(ilp != NULL);
925 	ASSERT(isp != NULL);
926 	ASSERT(icmdp != NULL);
927 
928 	/*
929 	 * If the session is in the FREE state then
930 	 * all connections are down and retries have
931 	 * been exhausted.  Fail command with fatal error.
932 	 */
933 	rw_enter(&isp->sess_state_rwlock, RW_READER);
934 	if (isp->sess_state == ISCSI_SESS_STATE_FREE) {
935 		rw_exit(&isp->sess_state_rwlock);
936 		return (TRAN_FATAL_ERROR);
937 	}
938 
939 	/*
940 	 * If we haven't received data from the target in the
941 	 * max specified period something is wrong with the
942 	 * transport.  Fail IO with FATAL_ERROR.
943 	 */
944 	if (isp->sess_rx_lbolt + SEC_TO_TICK(iscsi_rx_max_window) <
945 	    ddi_get_lbolt()) {
946 		rw_exit(&isp->sess_state_rwlock);
947 		return (TRAN_FATAL_ERROR);
948 	}
949 
950 	/*
951 	 * If the session is not in LOGGED_IN then we have
952 	 * no connections LOGGED_IN, but we haven't exhuasted
953 	 * our retries.  Fail the command with busy so the
954 	 * caller might try again later.  Once retries are
955 	 * exhausted the state machine will move us to FREE.
956 	 */
957 	if (isp->sess_state != ISCSI_SESS_STATE_LOGGED_IN) {
958 		rw_exit(&isp->sess_state_rwlock);
959 		return (TRAN_BUSY);
960 	}
961 
962 	/*
963 	 * If we haven't received data from the target in the
964 	 * specified period something is probably wrong with
965 	 * the transport.  Just return back BUSY until either
966 	 * the problem is resolved of the transport fails.
967 	 */
968 	if (isp->sess_rx_lbolt + SEC_TO_TICK(iscsi_rx_window) <
969 	    ddi_get_lbolt()) {
970 		rw_exit(&isp->sess_state_rwlock);
971 		return (TRAN_BUSY);
972 	}
973 
974 
975 	/* reset cmd values in case upper level driver is retrying cmd */
976 	icmdp->cmd_prev = icmdp->cmd_next = NULL;
977 	icmdp->cmd_crc_error_seen = B_FALSE;
978 	icmdp->cmd_lbolt_pending = icmdp->cmd_lbolt_active =
979 	    icmdp->cmd_lbolt_aborting = icmdp->cmd_lbolt_timeout =
980 	    (clock_t)NULL;
981 	icmdp->cmd_itt = icmdp->cmd_ttt = 0;
982 	icmdp->cmd_un.scsi.abort_icmdp = NULL;
983 
984 	mutex_enter(&isp->sess_queue_pending.mutex);
985 	iscsi_cmd_state_machine(icmdp, ISCSI_CMD_EVENT_E1, isp);
986 	mutex_exit(&isp->sess_queue_pending.mutex);
987 	rw_exit(&isp->sess_state_rwlock);
988 
989 	/*
990 	 * If this packet doesn't have FLAG_NOINTR set, it could have
991 	 * already run to completion (and the memory freed) at this
992 	 * point, so check our local copy of pkt_flags.  Otherwise we
993 	 * have to wait for completion before returning to the caller.
994 	 */
995 	if (flags & FLAG_NOINTR) {
996 		mutex_enter(&icmdp->cmd_mutex);
997 		while ((icmdp->cmd_state != ISCSI_CMD_STATE_COMPLETED) ||
998 		    (icmdp->cmd_un.scsi.r2t_icmdp != NULL) ||
999 		    (icmdp->cmd_un.scsi.abort_icmdp != NULL) ||
1000 		    (icmdp->cmd_un.scsi.r2t_more == B_TRUE)) {
1001 			cv_wait(&icmdp->cmd_completion, &icmdp->cmd_mutex);
1002 		}
1003 		icmdp->cmd_state = ISCSI_CMD_STATE_FREE;
1004 		mutex_exit(&icmdp->cmd_mutex);
1005 	}
1006 
1007 	return (TRAN_ACCEPT);
1008 }
1009 
1010 /*
1011  * iscsi_tran_abort - Called when an upper level application
1012  * or driver wants to kill a scsi_pkt that was already sent to
1013  * this driver.
1014  */
1015 /* ARGSUSED */
1016 static int
iscsi_tran_abort(struct scsi_address * ap,struct scsi_pkt * pkt)1017 iscsi_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
1018 {
1019 	return (0);
1020 }
1021 
1022 /*
1023  * iscsi_tran_reset - Reset target at either BUS, TARGET, or LUN
1024  * level.  This will require the issuing of a task management
1025  * command down to the target/lun.
1026  */
1027 static int
iscsi_tran_reset(struct scsi_address * ap,int level)1028 iscsi_tran_reset(struct scsi_address *ap, int level)
1029 {
1030 	int		rval    = ISCSI_STATUS_INTERNAL_ERROR;
1031 	iscsi_sess_t	*isp    = NULL;
1032 	iscsi_lun_t	*ilp    = NULL;
1033 
1034 	ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private;
1035 	ASSERT(ilp != NULL);
1036 	isp = ilp->lun_sess;
1037 	ASSERT(isp != NULL);
1038 
1039 	switch (level) {
1040 	case RESET_LUN:
1041 		/* reset attempt will block until attempt is complete */
1042 		rval = iscsi_handle_reset(isp, level, ilp);
1043 		break;
1044 	case RESET_BUS:
1045 		/*
1046 		 * What are we going to realy reset the ethernet
1047 		 * network!?  Just fall through to a target reset.
1048 		 */
1049 	case RESET_TARGET:
1050 		/* reset attempt will block until attempt is complete */
1051 		rval = iscsi_handle_reset(isp, level, NULL);
1052 		break;
1053 	case RESET_ALL:
1054 	default:
1055 		break;
1056 	}
1057 
1058 	return (ISCSI_SUCCESS(rval) ? 1 : 0);
1059 }
1060 
1061 /*
1062  * iscsi_tran_getcap - Get target/lun capabilities.
1063  */
1064 static int
iscsi_tran_getcap(struct scsi_address * ap,char * cap,int whom)1065 iscsi_tran_getcap(struct scsi_address *ap, char *cap, int whom)
1066 {
1067 	return (iscsi_i_commoncap(ap, cap, 0, whom, 0));
1068 }
1069 
1070 
1071 /*
1072  * iscsi_tran_setcap - Set target/lun capabilities.
1073  */
1074 /* ARGSUSED */
1075 static int
iscsi_tran_setcap(struct scsi_address * ap,char * cap,int value,int whom)1076 iscsi_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom)
1077 {
1078 	return (iscsi_i_commoncap(ap, cap, value, whom, 1));
1079 }
1080 
1081 
1082 /*
1083  * iscsi_tran_destroy_pkt - Clean up packet
1084  */
1085 static void
iscsi_tran_destroy_pkt(struct scsi_address * ap,struct scsi_pkt * pkt)1086 iscsi_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1087 {
1088 	iscsi_cmd_t	*icmdp;
1089 
1090 	icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private;
1091 
1092 	ASSERT(icmdp != NULL);
1093 	ASSERT(icmdp->cmd_sig == ISCSI_SIG_CMD);
1094 	ASSERT(icmdp->cmd_state == ISCSI_CMD_STATE_FREE);
1095 
1096 	iscsi_lun_rele(icmdp->cmd_lun);
1097 	mutex_destroy(&icmdp->cmd_mutex);
1098 	cv_destroy(&icmdp->cmd_completion);
1099 	scsi_hba_pkt_free(ap, pkt);
1100 }
1101 
1102 /*
1103  * iscsi_tran_dmafree - This is a software driver, NO DMA
1104  */
1105 /* ARGSUSED */
1106 static void
iscsi_tran_dmafree(struct scsi_address * ap,struct scsi_pkt * pkt)1107 iscsi_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
1108 {
1109 	/*
1110 	 * The iSCSI interface doesn't deal with DMA
1111 	 */
1112 }
1113 
1114 /*
1115  * iscsi_tran_sync_pkt - This is a software driver, NO DMA
1116  */
1117 /* ARGSUSED */
1118 static void
iscsi_tran_sync_pkt(struct scsi_address * ap,struct scsi_pkt * pkt)1119 iscsi_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1120 {
1121 	/*
1122 	 * The iSCSI interface doesn't deal with DMA
1123 	 */
1124 }
1125 
1126 /*
1127  * iscsi_tran_reset_notify - We don't support BUS_RESET so there
1128  * is no point in support callback.
1129  */
1130 /* ARGSUSED */
1131 static int
iscsi_tran_reset_notify(struct scsi_address * ap,int flag,void (* callback)(caddr_t),caddr_t arg)1132 iscsi_tran_reset_notify(struct scsi_address *ap, int flag,
1133     void (*callback) (caddr_t), caddr_t arg)
1134 {
1135 
1136 	/*
1137 	 * We never do BUS_RESETS so allowing this call
1138 	 * back to register has no point?
1139 	 */
1140 	return (DDI_SUCCESS);
1141 }
1142 
1143 
1144 /*
1145  * iscsi_tran_bus_config - on demand device configuration
1146  *
1147  * iscsi_tran_bus_config is called by the NDI layer at the completion
1148  * of a dev_node creation.  There are two primary cases defined in this
1149  * function.  The first is BUS_CONFIG_ALL.  In this case the NDI is trying
1150  * to identify that targets/luns are available configured at that point
1151  * in time.  It is safe to just complete the process succcessfully.  The
1152  * second case is a new case that was defined in S10 for devfs.  BUS_CONFIG_ONE
1153  * this is to help driver the top down discovery instead of bottom up.  If
1154  * we receive a BUS_CONFIG_ONE we should check to see if the <addr> exists
1155  * if so complete successfull processing.  Otherwise we should call the
1156  * deamon and see if we can plumb the <addr>.  If it is possible to plumb the
1157  * <addr> block until plumbing is complete.  In both cases of being able to
1158  * plumb <addr> or not continue with successfull processing.
1159  */
1160 static int
iscsi_tran_bus_config(dev_info_t * parent,uint_t flags,ddi_bus_config_op_t op,void * arg,dev_info_t ** childp)1161 iscsi_tran_bus_config(dev_info_t *parent, uint_t flags,
1162     ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
1163 {
1164 	int		rval	= NDI_SUCCESS;
1165 	iscsi_hba_t	*ihp	= NULL;
1166 	int		iflags	= flags;
1167 	char		*name	= NULL;
1168 	char		*ptr	= NULL;
1169 	boolean_t	config_root = B_FALSE;
1170 
1171 	/* get reference to soft state */
1172 	ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state,
1173 	    ddi_get_instance(parent));
1174 	if (ihp == NULL) {
1175 		return (NDI_FAILURE);
1176 	}
1177 
1178 	iscsi_check_miniroot(ihp);
1179 	if ((modrootloaded == 0) && (iscsiboot_prop != NULL)) {
1180 		config_root = B_TRUE;
1181 	}
1182 
1183 	if (config_root == B_FALSE) {
1184 		if (iscsi_client_request_service(ihp) == B_FALSE) {
1185 			return (NDI_FAILURE);
1186 		}
1187 	}
1188 
1189 	/* lock so only one config operation occrs */
1190 	sema_p(&iscsid_config_semaphore);
1191 
1192 	switch (op) {
1193 	case BUS_CONFIG_ONE:
1194 		/* parse target name out of name given */
1195 		if ((ptr = strchr((char *)arg, '@')) == NULL) {
1196 			rval = NDI_FAILURE;
1197 			break;
1198 		}
1199 		ptr++;		/* move past '@' */
1200 		name = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP);
1201 		(void) strncpy(name, ptr, MAX_GET_NAME_SIZE);
1202 		/* We need to strip the LUN */
1203 		if ((ptr = strchr(name, ',')) == NULL) {
1204 			rval = NDI_FAILURE;
1205 			kmem_free(name, MAX_GET_NAME_SIZE);
1206 			name = NULL;
1207 			break;
1208 		}
1209 		/* We also need to strip the 4 bytes of hex TPGT */
1210 		ptr -= 4;
1211 		if (ptr <= name) {
1212 			rval = NDI_FAILURE;
1213 			kmem_free(name, MAX_GET_NAME_SIZE);
1214 			name = NULL;
1215 			break;
1216 		}
1217 		*ptr = '\0';		/* NULL terminate */
1218 
1219 		/* translate name back to original iSCSI name */
1220 		iscsi_get_name_to_iqn(name, MAX_GET_NAME_SIZE);
1221 
1222 		/* configure target, skip 4 byte ISID */
1223 		iscsid_config_one(ihp, (name+4), B_TRUE);
1224 
1225 		kmem_free(name, MAX_GET_NAME_SIZE);
1226 		name = NULL;
1227 
1228 		/*
1229 		 * DDI group instructed us to use this flag.
1230 		 */
1231 		iflags |= NDI_MDI_FALLBACK;
1232 		break;
1233 	case BUS_CONFIG_DRIVER:
1234 		/* FALLTHRU */
1235 	case BUS_CONFIG_ALL:
1236 		iscsid_config_all(ihp, B_TRUE);
1237 		break;
1238 	default:
1239 		rval = NDI_FAILURE;
1240 		break;
1241 	}
1242 
1243 	if (rval == NDI_SUCCESS) {
1244 		rval = ndi_busop_bus_config(parent, iflags,
1245 		    op, arg, childp, 0);
1246 	}
1247 	sema_v(&iscsid_config_semaphore);
1248 
1249 	if (config_root == B_FALSE) {
1250 		iscsi_client_release_service(ihp);
1251 	}
1252 
1253 	return (rval);
1254 }
1255 
1256 /*
1257  * iscsi_tran_bus_unconfig - on demand device unconfiguration
1258  *
1259  * Called by the os framework under low resource situations.
1260  * It will attempt to unload our minor nodes (logical units
1261  * ndi/mdi nodes).
1262  */
1263 static int
iscsi_tran_bus_unconfig(dev_info_t * parent,uint_t flag,ddi_bus_config_op_t op,void * arg)1264 iscsi_tran_bus_unconfig(dev_info_t *parent, uint_t flag,
1265     ddi_bus_config_op_t op, void *arg)
1266 {
1267 	int		rval = NDI_SUCCESS;
1268 	iscsi_hba_t	*ihp = NULL;
1269 
1270 	/* get reference to soft state */
1271 	ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state,
1272 	    ddi_get_instance(parent));
1273 	if (ihp == NULL) {
1274 		return (NDI_FAILURE);
1275 	}
1276 
1277 	if (iscsi_client_request_service(ihp) == B_FALSE) {
1278 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
1279 		if (ihp->hba_sess_list != NULL) {
1280 			rval = NDI_FAILURE;
1281 		}
1282 		rw_exit(&ihp->hba_sess_list_rwlock);
1283 		return (rval);
1284 	}
1285 
1286 	rval = ndi_busop_bus_unconfig(parent, flag, op, arg);
1287 
1288 	iscsi_client_release_service(ihp);
1289 
1290 	return (rval);
1291 }
1292 
1293 
1294 /*
1295  * iscsi_tran_get_name - create private /devices name for LUN
1296  *
1297  * This creates the <addr> in /devices/iscsi/<driver>@<addr>
1298  * path.  For this <addr> we return the <session/target_name>,<lun num>
1299  * Where <target_name> is an <iqn/eui/...> as defined by the iSCSI
1300  * specification.  We do modify the name slightly so that it still
1301  * complies with the IEEE <addr> naming scheme.  This means that we
1302  * will substitute out the ':', '@', ... and other reserved characters
1303  * defined in the IEEE definition with '%<hex value of special char>'
1304  * This routine is indirectly called by iscsi_lun_create_xxx.  These
1305  * calling routines must prevent the session and lun lists from changing
1306  * during this routine.
1307  */
1308 static int
iscsi_tran_get_name(struct scsi_device * sd,char * name,int len)1309 iscsi_tran_get_name(struct scsi_device *sd, char *name, int len)
1310 {
1311 	int		target		= 0;
1312 	int		lun		= 0;
1313 	iscsi_hba_t	*ihp		= NULL;
1314 	iscsi_sess_t	*isp		= NULL;
1315 	iscsi_lun_t	*ilp		= NULL;
1316 	dev_info_t	*lun_dip	= NULL;
1317 
1318 	ASSERT(sd != NULL);
1319 	ASSERT(name != NULL);
1320 	lun_dip = sd->sd_dev;
1321 	ASSERT(lun_dip != NULL);
1322 
1323 	/* get reference to soft state */
1324 	ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state,
1325 	    ddi_get_instance(ddi_get_parent(lun_dip)));
1326 	if (ihp == NULL) {
1327 		name[0] = '\0';
1328 		return (0);
1329 	}
1330 
1331 	/* Get the target num */
1332 	target = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev,
1333 	    DDI_PROP_DONTPASS, TARGET_PROP, 0);
1334 
1335 	/* Get the target num */
1336 	lun = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev,
1337 	    DDI_PROP_DONTPASS, LUN_PROP, 0);
1338 
1339 	/*
1340 	 * Now we need to find our ilp by walking the lists
1341 	 * off the ihp and isp.
1342 	 */
1343 	/* See if we already created this session */
1344 
1345 	/* Walk the HBA's session list */
1346 	for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) {
1347 		/* compare target name as the unique identifier */
1348 		if (target == isp->sess_oid) {
1349 			/* found match */
1350 			break;
1351 		}
1352 	}
1353 
1354 	/* If we found matching session continue searching for tgt */
1355 	if (isp == NULL) {
1356 		/* sess not found */
1357 		name[0] = '\0';
1358 		return (0);
1359 	}
1360 
1361 	/*
1362 	 * Search for the matching iscsi lun structure.  We don't
1363 	 * need to hold the READER for the lun list at this point.
1364 	 * because the tran_get_name is being called from the online
1365 	 * function which is already holding a reader on the lun
1366 	 * list.
1367 	 */
1368 	for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) {
1369 		if (lun == ilp->lun_num) {
1370 			/* found match */
1371 			break;
1372 		}
1373 	}
1374 
1375 	if (ilp == NULL) {
1376 		/* tgt not found */
1377 		name[0] = '\0';
1378 		return (0);
1379 	}
1380 
1381 	/* Ensure enough space for lun_addr is available */
1382 	ASSERT(ilp->lun_addr != NULL);
1383 	if ((strlen(ilp->lun_addr) + 1) > len) {
1384 		return (0);
1385 	}
1386 
1387 	/* copy lun_addr name */
1388 	(void) strcpy(name, ilp->lun_addr);
1389 
1390 	/*
1391 	 * Based on IEEE-1275 we can't have any ':', ' ', '@', or '/'
1392 	 * characters in our naming.  So replace all those characters
1393 	 * with '-'
1394 	 */
1395 	iscsi_get_name_from_iqn(name, len);
1396 
1397 	return (1);
1398 }
1399 
1400 /*
1401  * iscsi_tran_get_bus_addr - This returns a human readable string
1402  * for the bus address.  Examining most other drivers fcp, etc.  They
1403  * all just return the same string as tran_get_name.  In our case
1404  * our tran get name is already some what usable so leave alone.
1405  */
1406 static int
iscsi_tran_get_bus_addr(struct scsi_device * sd,char * name,int len)1407 iscsi_tran_get_bus_addr(struct scsi_device *sd, char *name, int len)
1408 {
1409 	return (iscsi_tran_get_name(sd, name, len));
1410 }
1411 
1412 
1413 /*
1414  * +--------------------------------------------------------------------+
1415  * | End of scsi_tran routines					  |
1416  * +--------------------------------------------------------------------+
1417  */
1418 
1419 /*
1420  * +--------------------------------------------------------------------+
1421  * | Start of cb_ops routines					   |
1422  * +--------------------------------------------------------------------+
1423  */
1424 
1425 /*
1426  * iscsi_open - Driver should be made IOCTL MT safe.  Otherwise
1427  * this function needs updated.
1428  */
1429 /* ARGSUSED */
1430 static int
iscsi_open(dev_t * devp,int flags,int otyp,cred_t * credp)1431 iscsi_open(dev_t *devp, int flags, int otyp, cred_t *credp)
1432 {
1433 	return (0);
1434 }
1435 
1436 /*
1437  * iscsi_close -
1438  */
1439 /* ARGSUSED */
1440 static int
iscsi_close(dev_t dev,int flags,int otyp,cred_t * credp)1441 iscsi_close(dev_t dev, int flags, int otyp, cred_t *credp)
1442 {
1443 	return (0);
1444 }
1445 
1446 /*
1447  * iscsi_ioctl -
1448  */
1449 /* ARGSUSED */
1450 static int
iscsi_ioctl(dev_t dev,int cmd,intptr_t arg,int mode,cred_t * credp,int * rvalp)1451 iscsi_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
1452     cred_t *credp, int *rvalp)
1453 {
1454 	int			rtn		= 0;
1455 	int			instance	= 0;
1456 	int			list_space	= 0;
1457 	int			lun_sz		= 0;
1458 	int			did;
1459 	int			retry;
1460 	iscsi_hba_t		*ihp		= NULL;
1461 	iscsi_sess_t		*isp		= NULL;
1462 	iscsi_conn_t		*icp		= NULL;
1463 	iscsi_login_params_t	*params		= NULL;
1464 	iscsi_login_params_t	*tmpParams	= NULL;
1465 	uchar_t			*name		= NULL;
1466 	dev_info_t		*lun_dip	= NULL;
1467 
1468 	entry_t			    e;
1469 	iscsi_oid_t		    oid;
1470 	iscsi_property_t	    *ipp;
1471 	iscsi_static_property_t	    *ispp;
1472 	iscsi_param_get_t	    *ilg;
1473 	iscsi_param_set_t	    *ils;
1474 	iscsi_target_list_t	    idl, *idlp		= NULL;
1475 	iscsi_addr_list_t	    ial, *ialp		= NULL;
1476 	iscsi_chap_props_t	    *chap		= NULL;
1477 	iscsi_radius_props_t	    *radius		= NULL;
1478 	iscsi_auth_props_t	    *auth		= NULL;
1479 	iscsi_lun_list_t	    *ll, *llp		= NULL;
1480 	iscsi_lun_props_t	    *lun		= NULL;
1481 	iscsi_lun_t		    *ilp		= NULL;
1482 	iSCSIDiscoveryMethod_t	    method;
1483 	iSCSIDiscoveryProperties_t  discovery_props;
1484 	iscsi_uscsi_t		    iu;
1485 	iscsi_uscsi_t		    iu_caller;
1486 #ifdef _MULTI_DATAMODEL
1487 	/* For use when a 32 bit app makes a call into a 64 bit ioctl */
1488 	iscsi_uscsi32_t		    iu32_caller;
1489 	model_t			    model;
1490 #endif /* _MULTI_DATAMODEL */
1491 	void			    *void_p;
1492 	iscsi_sendtgts_list_t	*stl_hdr;
1493 	iscsi_sendtgts_list_t	*istl;
1494 	int			stl_sz;
1495 	iscsi_target_entry_t	*target;
1496 	uint32_t		old_oid;
1497 	uint32_t		target_oid;
1498 	iscsi_targetparam_entry_t *curr_entry;
1499 	char			*initiator_node_name;
1500 	char			*initiator_node_alias;
1501 	isns_portal_group_list_t    *pg_list = NULL;
1502 	isns_server_portal_group_list_t    *server_pg_list_hdr = NULL;
1503 	isns_server_portal_group_list_t    *server_pg_list = NULL;
1504 	int			pg_list_sz, pg_sz_copy_out, server_pg_list_sz;
1505 	iscsi_config_sess_t	*ics;
1506 	int			size;
1507 	boolean_t		rval;
1508 	char			init_port_name[MAX_NAME_PROP_SIZE];
1509 	iscsi_sockaddr_t	addr_dsc;
1510 	iscsi_boot_property_t	*bootProp;
1511 	boolean_t		discovered = B_TRUE;
1512 	iscsi_tunable_object_t	*tpsg;
1513 	iscsi_tunable_object_t	*tpss;
1514 	iscsi_reen_t	*reenum;
1515 
1516 	instance = getminor(dev);
1517 	ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state, instance);
1518 	if (ihp == NULL)
1519 		return (EFAULT);
1520 
1521 	iscsi_check_miniroot(ihp);
1522 	if ((cmd != ISCSI_SMF_ONLINE) && (cmd != ISCSI_SMF_OFFLINE) &&
1523 	    (cmd != ISCSI_SMF_GET)) {
1524 		/* other cmd needs to acquire the service */
1525 		if (iscsi_client_request_service(ihp) == B_FALSE) {
1526 			return (EFAULT);
1527 		}
1528 	}
1529 
1530 	switch (cmd) {
1531 	/*
1532 	 * ISCSI_CREATE_OID - Create a Object IDentifier for a TargetName
1533 	 */
1534 	case ISCSI_CREATE_OID:
1535 		if (ddi_copyin((caddr_t)arg, &oid, sizeof (oid), mode)) {
1536 			rtn = EFAULT;
1537 			break;
1538 		}
1539 		if (oid.o_vers != ISCSI_INTERFACE_VERSION) {
1540 			rtn = EINVAL;
1541 			break;
1542 		}
1543 
1544 		/* Set the target that this session is associated with */
1545 		oid.o_oid = iscsi_targetparam_get_oid(oid.o_name);
1546 
1547 		if (ddi_copyout(&oid, (caddr_t)arg, sizeof (oid), mode)) {
1548 			rtn = EFAULT;
1549 			break;
1550 		}
1551 		break;
1552 	/*
1553 	 * ISCSI_PARAM_GET - Get param for specified
1554 	 * connection/session.
1555 	 */
1556 	case ISCSI_PARAM_GET:
1557 		/* copyin user args */
1558 		ilg = (iscsi_param_get_t *)kmem_alloc(sizeof (*ilg), KM_SLEEP);
1559 		if (ddi_copyin((caddr_t)arg, ilg, sizeof (*ilg), mode)) {
1560 			rtn = EFAULT;
1561 			kmem_free(ilg, sizeof (*ilg));
1562 			break;
1563 		}
1564 
1565 		if (ilg->g_vers != ISCSI_INTERFACE_VERSION) {
1566 			rtn = EINVAL;
1567 			kmem_free(ilg, sizeof (*ilg));
1568 			break;
1569 		}
1570 
1571 		/* handle special case for Initiator name */
1572 		if (ilg->g_param == ISCSI_LOGIN_PARAM_INITIATOR_NAME) {
1573 			(void) strlcpy((char *)ilg->g_value.v_name,
1574 			    (char *)ihp->hba_name, ISCSI_MAX_NAME_LEN);
1575 		} else if (ilg->g_param == ISCSI_LOGIN_PARAM_INITIATOR_ALIAS) {
1576 			if (ihp->hba_alias_length == 0) {
1577 				rtn = EINVAL;
1578 			} else {
1579 				(void) strlcpy((char *)ilg->g_value.v_name,
1580 				    (char *)ihp->hba_alias, ISCSI_MAX_NAME_LEN);
1581 			}
1582 		} else {
1583 			/* To describe the validity of the requested param */
1584 			boolean_t valid_flag = B_TRUE;
1585 
1586 			name = NULL;
1587 
1588 			/*
1589 			 * switch login based if looking for initiator
1590 			 * params
1591 			 */
1592 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
1593 			if (ilg->g_oid == ihp->hba_oid) {
1594 				/* initiator */
1595 				params = &ihp->hba_params;
1596 				name = ihp->hba_name;
1597 				if (iscsi_get_persisted_param(name,
1598 				    ilg, params) != 0) {
1599 					valid_flag = B_FALSE;
1600 				}
1601 			} else {
1602 				/*
1603 				 * If the oid does represent a session check
1604 				 * to see if it is a target oid.  If so,
1605 				 * return the target's associated session.
1606 				 */
1607 				rtn = iscsi_sess_get(ilg->g_oid, ihp, &isp);
1608 				if (rtn != 0) {
1609 					rtn = iscsi_sess_get_by_target(
1610 					    ilg->g_oid, ihp, &isp);
1611 				}
1612 
1613 				/*
1614 				 * If rtn is zero then we have found an
1615 				 * existing session.  Use the session name to
1616 				 * do param lookup.  If rtn is non-zero then
1617 				 * create a targetparam object and use its name
1618 				 * for param lookup.
1619 				 */
1620 				if (rtn == 0) {
1621 					name = isp->sess_name;
1622 					params = &isp->sess_params;
1623 				} else {
1624 					name =
1625 					    iscsi_targetparam_get_name(
1626 					    ilg->g_oid);
1627 					if (ilg->g_param_type ==
1628 					    ISCSI_SESS_PARAM) {
1629 						tmpParams =
1630 						    (iscsi_login_params_t *)
1631 						    kmem_alloc(
1632 						    sizeof (*tmpParams),
1633 						    KM_SLEEP);
1634 						params = tmpParams;
1635 					}
1636 					rtn = 0;
1637 				}
1638 
1639 				if (name == NULL) {
1640 					rw_exit(
1641 					    &ihp->hba_sess_list_rwlock);
1642 					rtn = EFAULT;
1643 					kmem_free(ilg, sizeof (*ilg));
1644 					if (tmpParams != NULL)
1645 						kmem_free(tmpParams,
1646 						    sizeof (*tmpParams));
1647 
1648 					break;
1649 				}
1650 
1651 				if (ilg->g_param_type == ISCSI_SESS_PARAM) {
1652 					/* session */
1653 					/*
1654 					 * Update sess_params with the
1655 					 * latest params from the
1656 					 * persistent store.
1657 					 */
1658 					if (iscsi_get_persisted_param(name,
1659 					    ilg, params) != 0) {
1660 						/*
1661 						 * If the parameter in
1662 						 * question is not
1663 						 * overriden, no effect
1664 						 * on existing session
1665 						 * parameters. However,
1666 						 * the parameter is
1667 						 * marked invalid
1668 						 * (from the standpoint
1669 						 * of whether it is
1670 						 * overriden).
1671 						 */
1672 						valid_flag = B_FALSE;
1673 					}
1674 				} else if (ilg->g_param_type ==
1675 				    ISCSI_CONN_PARAM && isp != NULL) {
1676 					/* connection */
1677 					rw_enter(&isp->sess_conn_list_rwlock,
1678 					    RW_READER);
1679 					/* Assuming 1 conn per sess. */
1680 					/*
1681 					 * MC/S - Need to be modified to
1682 					 * take g_conn_cid into account when
1683 					 * we go multi-connection.
1684 					 */
1685 					if ((isp->sess_conn_act != NULL) &&
1686 					    (isp->sess_conn_act->conn_state ==
1687 					    ISCSI_CONN_STATE_LOGGED_IN)) {
1688 						params = &(isp->
1689 						    sess_conn_act->
1690 						    conn_params);
1691 					} else {
1692 						valid_flag = B_FALSE;
1693 					}
1694 					rw_exit(&isp->sess_conn_list_rwlock);
1695 				}
1696 			}
1697 
1698 			/* make sure we have params to get info from */
1699 			if (params) {
1700 				rtn = iscsi_get_param(params, valid_flag, ilg);
1701 
1702 				/*
1703 				 * for target parameters, check if any
1704 				 * parameters were overridden at the initiator
1705 				 * level. If so, then change the default value
1706 				 * to the initiator's overridden value
1707 				 */
1708 				if ((rtn == 0) &&
1709 				    (ilg->g_oid != ihp->hba_oid)) {
1710 					iscsi_override_target_default(ihp,
1711 					    ilg);
1712 				}
1713 			}
1714 			rw_exit(&ihp->hba_sess_list_rwlock);
1715 		}
1716 
1717 		if (rtn == 0) {
1718 			rtn = ddi_copyout(ilg, (caddr_t)arg,
1719 			    sizeof (iscsi_param_get_t), mode);
1720 		}
1721 		kmem_free(ilg, sizeof (*ilg));
1722 		if (tmpParams != NULL)
1723 			kmem_free(tmpParams, sizeof (*tmpParams));
1724 		break;
1725 
1726 	/*
1727 	 * ISCSI_INIT_NODE_NAME_SET - Change the initiator-node name for
1728 	 * the specified connection/session.
1729 	 */
1730 	case ISCSI_INIT_NODE_NAME_SET:
1731 		/* copyin user args */
1732 		ils = (iscsi_param_set_t *)kmem_alloc(sizeof (*ils), KM_SLEEP);
1733 		if (ddi_copyin((caddr_t)arg, ils, sizeof (*ils), mode)) {
1734 			rtn = EFAULT;
1735 			kmem_free(ils, sizeof (*ils));
1736 			break;
1737 		}
1738 
1739 		if (ils->s_vers != ISCSI_INTERFACE_VERSION) {
1740 			rtn = EINVAL;
1741 			kmem_free(ils, sizeof (*ils));
1742 			break;
1743 		}
1744 
1745 		/* saving off the old initiator-node name */
1746 		initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
1747 		rval = persistent_initiator_name_get(initiator_node_name,
1748 		    ISCSI_MAX_NAME_LEN);
1749 
1750 		rtn = iscsi_set_params(ils, ihp, B_TRUE);
1751 		kmem_free(ils, sizeof (*ils));
1752 		if (rtn != 0) {
1753 			kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
1754 			initiator_node_name = NULL;
1755 			break;
1756 		}
1757 
1758 		(void) snprintf(init_port_name, MAX_NAME_PROP_SIZE,
1759 		    "%s,%02x%02x%02x%02x%02x%02x",
1760 		    (char *)ihp->hba_name, ihp->hba_isid[0],
1761 		    ihp->hba_isid[1], ihp->hba_isid[2],
1762 		    ihp->hba_isid[3], ihp->hba_isid[4],
1763 		    ihp->hba_isid[5]);
1764 
1765 		if (ddi_prop_update_string(DDI_DEV_T_NONE,
1766 		    ihp->hba_dip, SCSI_ADDR_PROP_INITIATOR_PORT,
1767 		    init_port_name) != DDI_PROP_SUCCESS) {
1768 			cmn_err(CE_WARN, "iscsi_ioctl: Updating "
1769 			    SCSI_ADDR_PROP_INITIATOR_PORT " property on iSCSI "
1770 			    "HBA(%s) with dip(%d) Failed",
1771 			    (char *)ihp->hba_name,
1772 			    ddi_get_instance(ihp->hba_dip));
1773 		}
1774 
1775 		/*
1776 		 * Deregister the old initiator-node name from the iSNS
1777 		 * server
1778 		 * Register the new initiator-node name with the iSNS server
1779 		 */
1780 		method = persistent_disc_meth_get();
1781 		if (method & iSCSIDiscoveryMethodISNS) {
1782 			if (rval == B_TRUE) {
1783 				if (strlen(initiator_node_name) > 0) {
1784 				/*
1785 				 * we will attempt to offline the targets.
1786 				 * if logouts fail, we will still continue
1787 				 */
1788 #define	STRING_INNO "initiator-node name - Offline "
1789 #define	STRING_FFOMD "failed for one or more devices"
1790 					if ((iscsid_del(
1791 					    ihp, NULL, method, NULL))
1792 					    != B_TRUE) {
1793 						cmn_err(CE_NOTE,
1794 						    "Attempting to change "
1795 						    STRING_INNO
1796 						    STRING_FFOMD);
1797 					}
1798 					(void) isns_dereg(ihp->hba_isid,
1799 					    (uint8_t *)initiator_node_name);
1800 #undef STRING_INNO
1801 #undef STRING_FFOMD
1802 				}
1803 			}
1804 			if (persistent_initiator_name_get(initiator_node_name,
1805 			    ISCSI_MAX_NAME_LEN) != B_TRUE) {
1806 				kmem_free(initiator_node_name,
1807 				    ISCSI_MAX_NAME_LEN);
1808 				initiator_node_name = NULL;
1809 				rtn = EIO;
1810 				break;
1811 			}
1812 			if (strlen(initiator_node_name) == 0) {
1813 				kmem_free(initiator_node_name,
1814 				    ISCSI_MAX_NAME_LEN);
1815 				initiator_node_name = NULL;
1816 				rtn = EIO;
1817 				break;
1818 			}
1819 
1820 			initiator_node_alias = kmem_zalloc(ISCSI_MAX_NAME_LEN,
1821 			    KM_SLEEP);
1822 			if (persistent_alias_name_get(initiator_node_alias,
1823 			    ISCSI_MAX_NAME_LEN) != B_TRUE) {
1824 				initiator_node_alias[0] = '\0';
1825 			}
1826 
1827 			(void) isns_reg(ihp->hba_isid,
1828 			    (uint8_t *)initiator_node_name,
1829 			    ISCSI_MAX_NAME_LEN,
1830 			    (uint8_t *)initiator_node_alias,
1831 			    ISCSI_MAX_NAME_LEN,
1832 			    ISNS_INITIATOR_NODE_TYPE,
1833 			    isns_scn_callback);
1834 			iscsid_do_isns_query(ihp);
1835 
1836 			kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN);
1837 			initiator_node_alias = NULL;
1838 		}
1839 
1840 		kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
1841 		initiator_node_name = NULL;
1842 		break;
1843 
1844 	/*
1845 	 * ISCSI_PARAM_SET - Set param for specified connection/session.
1846 	 */
1847 	case ISCSI_PARAM_SET:
1848 		/* copyin user args */
1849 		ils = (iscsi_param_set_t *)kmem_alloc(sizeof (*ils), KM_SLEEP);
1850 		if (ddi_copyin((caddr_t)arg, ils, sizeof (*ils), mode)) {
1851 			rtn = EFAULT;
1852 			kmem_free(ils, sizeof (*ils));
1853 			break;
1854 		}
1855 
1856 		if (ils->s_vers != ISCSI_INTERFACE_VERSION) {
1857 			rtn = EINVAL;
1858 			kmem_free(ils, sizeof (*ils));
1859 			break;
1860 		}
1861 		rtn = iscsi_set_params(ils, ihp, B_TRUE);
1862 		if (iscsiboot_prop) {
1863 			if (iscsi_cmp_boot_sess_oid(ihp, ils->s_oid)) {
1864 				/*
1865 				 * found active session for this object
1866 				 * or this is initiator's object
1867 				 * with mpxio enabled
1868 				 */
1869 				if (!iscsi_reconfig_boot_sess(ihp)) {
1870 					rtn = EINVAL;
1871 					kmem_free(ils, sizeof (*ils));
1872 					break;
1873 				}
1874 			}
1875 		}
1876 		kmem_free(ils, sizeof (*ils));
1877 		break;
1878 
1879 	/*
1880 	 * ISCSI_TARGET_PARAM_CLEAR
1881 	 * - remove custom parameter settings for a target.
1882 	 */
1883 	case ISCSI_TARGET_PARAM_CLEAR:
1884 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
1885 			rtn = EFAULT;
1886 			break;
1887 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
1888 			rtn = EINVAL;
1889 			break;
1890 		}
1891 
1892 		if ((e.e_oid != ihp->hba_oid) &&
1893 		    (e.e_oid != ISCSI_OID_NOTSET)) {
1894 			boolean_t rval1, rval2, rval3;
1895 			uchar_t	    *t_name;
1896 			iscsi_sess_t *t_isp;
1897 			boolean_t    t_rtn = B_TRUE;
1898 			persistent_param_t  t_param;
1899 			iscsi_config_sess_t t_ics;
1900 			persistent_tunable_param_t t_tpsg;
1901 
1902 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
1903 			/*
1904 			 * If the oid does represent a session check to see
1905 			 * if it is a target oid.  If so, return the target's
1906 			 * associated session.
1907 			 */
1908 			rtn = iscsi_sess_get(e.e_oid, ihp, &isp);
1909 			if (rtn != 0) {
1910 				rtn = iscsi_sess_get_by_target(e.e_oid, ihp,
1911 				    &isp);
1912 			}
1913 
1914 			/*
1915 			 * If rtn is zero then we have found an
1916 			 * existing session.  Use the session name to
1917 			 * do param lookup.  If rtn is non-zero then
1918 			 * create a targetparam object and use its name
1919 			 * for param lookup.
1920 			 */
1921 			if (rtn == 0) {
1922 				t_name = isp->sess_name;
1923 			} else {
1924 				t_name = iscsi_targetparam_get_name(e.e_oid);
1925 				rtn = 0;
1926 			}
1927 
1928 			if (t_name == NULL) {
1929 				rw_exit(&ihp->hba_sess_list_rwlock);
1930 				rtn = EFAULT;
1931 				break;
1932 			}
1933 
1934 			name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
1935 			(void) strncpy((char *)name, (char *)t_name,
1936 			    ISCSI_MAX_NAME_LEN);
1937 
1938 			t_ics.ics_in = 1;
1939 			rval1 = persistent_param_get((char *)name, &t_param);
1940 			rval2 = persistent_get_config_session((char *)name,
1941 			    &t_ics);
1942 			rval3 = persistent_get_tunable_param((char *)name,
1943 			    &t_tpsg);
1944 
1945 			if ((rval1 == B_FALSE) && (rval2 == B_FALSE) &&
1946 			    (rval3 == B_FALSE)) {
1947 				/* no any target parameters get */
1948 				kmem_free(name, ISCSI_MAX_NAME_LEN);
1949 				rw_exit(&ihp->hba_sess_list_rwlock);
1950 				rtn = EIO;
1951 				break;
1952 			}
1953 
1954 			if (persistent_param_clear((char *)name) == B_FALSE) {
1955 				kmem_free(name, ISCSI_MAX_NAME_LEN);
1956 				rw_exit(&ihp->hba_sess_list_rwlock);
1957 				rtn = EIO;
1958 				break;
1959 			}
1960 
1961 			ics = kmem_zalloc(sizeof (*ics), KM_SLEEP);
1962 			ics->ics_ver = ISCSI_INTERFACE_VERSION;
1963 			ics->ics_oid = ISCSI_INITIATOR_OID;
1964 			ics->ics_in  = 1;
1965 
1966 			/*
1967 			 * We may have multiple sessions with different
1968 			 * tpgt values.  So we need to loop through
1969 			 * the sessions and update all sessions.
1970 			 */
1971 			for (isp = ihp->hba_sess_list; isp;
1972 			    isp = t_isp) {
1973 				t_isp = isp->sess_next;
1974 
1975 				if (strncmp((char *)isp->sess_name,
1976 				    (char *)name, ISCSI_MAX_NAME_LEN) == 0) {
1977 					/*
1978 					 * When removing target-params we need
1979 					 * slightly different actions depending
1980 					 * on if the session should still exist.
1981 					 * Get the initiator-node value for
1982 					 * MS/T.  If there is no initiator
1983 					 * value then assume the default value
1984 					 * of 1.  If the initiator value is
1985 					 * less than this ISID then we need to
1986 					 * destroy the session.  Otherwise
1987 					 * update the session information and
1988 					 * resync (N7 event).
1989 					 */
1990 					rtn = iscsi_ioctl_get_config_sess(
1991 					    ihp, ics);
1992 					if (((rtn != 0) &&
1993 					    (isp->sess_isid[5] > 0)) ||
1994 					    ((rtn == 0) &&
1995 					    (ics->ics_out <=
1996 					    isp->sess_isid[5]))) {
1997 
1998 						/*
1999 						 * This session should no
2000 						 * longer exist.  Remove
2001 						 * session.
2002 						 */
2003 						if (!ISCSI_SUCCESS(
2004 						    iscsi_sess_destroy(isp))) {
2005 							t_rtn = B_FALSE;
2006 							continue;
2007 						}
2008 						isp = ihp->hba_sess_list;
2009 					} else {
2010 						uint32_t event_count;
2011 						/*
2012 						 * Reset the session
2013 						 * parameters.
2014 						 */
2015 						bcopy(&(isp->sess_hba->
2016 						    hba_params),
2017 						    &(isp->sess_params),
2018 						    sizeof (isp->sess_params));
2019 						if (iscsiboot_prop &&
2020 						    isp->sess_boot) {
2021 							/*
2022 							 * reconfig boot
2023 							 * session later
2024 							 */
2025 							continue;
2026 						}
2027 						/*
2028 						 * Notify the session that the
2029 						 * login parameters have
2030 						 * changed.
2031 						 */
2032 						event_count = atomic_inc_32_nv(
2033 						    &isp->
2034 						    sess_state_event_count);
2035 						iscsi_sess_enter_state_zone(
2036 						    isp);
2037 
2038 						iscsi_sess_state_machine(isp,
2039 						    ISCSI_SESS_EVENT_N7,
2040 						    event_count);
2041 
2042 						iscsi_sess_exit_state_zone(
2043 						    isp);
2044 					}
2045 				}
2046 			}
2047 			if (t_rtn == B_FALSE) {
2048 				boolean_t t_rval = B_TRUE;
2049 				/* Failure!, restore target's parameters */
2050 				if (rval1 == B_TRUE) {
2051 					rval1 = persistent_param_set(
2052 					    (char *)name, &t_param);
2053 					if (rval1 == B_FALSE) {
2054 						t_rval = B_FALSE;
2055 					}
2056 				}
2057 				if (rval2 == B_TRUE) {
2058 					rval2 = persistent_set_config_session(
2059 					    (char *)name, &t_ics);
2060 					if (rval2 == B_FALSE) {
2061 						t_rval = B_FALSE;
2062 					}
2063 				}
2064 				if (rval3 == B_TRUE) {
2065 					rval3 = persistent_set_tunable_param(
2066 					    (char *)name, &t_tpsg);
2067 					if (rval3 == B_FALSE) {
2068 						t_rval = B_FALSE;
2069 					}
2070 				}
2071 				if (t_rval == B_FALSE) {
2072 					cmn_err(CE_WARN, "Failed to restore "
2073 					    "target's parameters after remove "
2074 					    "session related to target "
2075 					    "parameters failure.");
2076 				}
2077 				rtn = EBUSY;
2078 			}
2079 			kmem_free(ics, sizeof (*ics));
2080 			kmem_free(name, ISCSI_MAX_NAME_LEN);
2081 			rw_exit(&ihp->hba_sess_list_rwlock);
2082 			if (iscsiboot_prop) {
2083 				if (iscsi_cmp_boot_sess_oid(ihp, e.e_oid)) {
2084 					/*
2085 					 * found active session for this object
2086 					 * or this is initiator object
2087 					 * with mpxio enabled
2088 					 */
2089 					if (!iscsi_reconfig_boot_sess(ihp)) {
2090 						rtn = EINVAL;
2091 						break;
2092 					}
2093 				}
2094 			}
2095 		}
2096 		break;
2097 
2098 	/*
2099 	 * ISCSI_TARGET_OID_LIST_GET -
2100 	 */
2101 	case ISCSI_TARGET_OID_LIST_GET:
2102 		/* copyin user args */
2103 		if (ddi_copyin((caddr_t)arg, &idl,
2104 		    sizeof (idl), mode)) {
2105 			rtn = EFAULT;
2106 			break;
2107 		}
2108 
2109 		if (idl.tl_vers != ISCSI_INTERFACE_VERSION) {
2110 			rtn = EINVAL;
2111 			break;
2112 		}
2113 
2114 		list_space = sizeof (iscsi_target_list_t);
2115 		if (idl.tl_in_cnt != 0)
2116 			list_space += (sizeof (uint32_t) *
2117 			    (idl.tl_in_cnt - 1));
2118 
2119 		idlp = kmem_zalloc(list_space, KM_SLEEP);
2120 		bcopy(&idl, idlp, sizeof (idl));
2121 		idlp->tl_out_cnt = 0;
2122 
2123 		/*
2124 		 * If target list type is ISCSI_TGT_OID_LIST and discovery
2125 		 * has not been completed or in progress, poke the discovery
2126 		 * methods so target information is returned
2127 		 */
2128 		mutex_enter(&ihp->hba_discovery_events_mutex);
2129 		method = ihp->hba_discovery_events;
2130 		if ((idl.tl_tgt_list_type == ISCSI_TGT_OID_LIST) &&
2131 		    (method != ISCSI_ALL_DISCOVERY_METHODS) &&
2132 		    (ihp->hba_discovery_in_progress == B_FALSE)) {
2133 			ihp->hba_discovery_in_progress = B_TRUE;
2134 			mutex_exit(&ihp->hba_discovery_events_mutex);
2135 			iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodUnknown);
2136 			mutex_enter(&ihp->hba_discovery_events_mutex);
2137 			ihp->hba_discovery_in_progress = B_FALSE;
2138 		}
2139 		mutex_exit(&ihp->hba_discovery_events_mutex);
2140 
2141 		/*
2142 		 * Return the correct list information based on the type
2143 		 */
2144 		switch (idl.tl_tgt_list_type) {
2145 		/* ISCSI_TGT_PARAM_OID_LIST - iscsiadm list target-params */
2146 		case ISCSI_TGT_PARAM_OID_LIST:
2147 			/* get params from persistent store */
2148 			iscsi_targetparam_lock_list(RW_READER);
2149 			curr_entry = iscsi_targetparam_get_next_entry(NULL);
2150 			while (curr_entry != NULL) {
2151 				if (idlp->tl_out_cnt < idlp->tl_in_cnt) {
2152 					idlp->tl_oid_list[idlp->tl_out_cnt] =
2153 					    curr_entry->target_oid;
2154 				}
2155 				idlp->tl_out_cnt++;
2156 				curr_entry = iscsi_targetparam_get_next_entry(
2157 				    curr_entry);
2158 			}
2159 			iscsi_targetparam_unlock_list();
2160 			break;
2161 
2162 		/* ISCSI_STATIC_TGT_OID_LIST - iscsiadm list static-config */
2163 		case ISCSI_STATIC_TGT_OID_LIST:
2164 		{
2165 			char *target_name = NULL;
2166 			void *v = NULL;
2167 
2168 			/* get static-config from persistent store */
2169 			target_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
2170 			persistent_static_addr_lock();
2171 			while (persistent_static_addr_next(&v,
2172 			    (char *)target_name, &e) == B_TRUE) {
2173 
2174 				if (idlp->tl_out_cnt < idlp->tl_in_cnt) {
2175 					idlp->tl_oid_list[idlp->tl_out_cnt] =
2176 					    e.e_oid;
2177 				}
2178 				idlp->tl_out_cnt++;
2179 
2180 			}
2181 
2182 			persistent_static_addr_unlock();
2183 			kmem_free(target_name, ISCSI_MAX_NAME_LEN);
2184 			break;
2185 		}
2186 
2187 		/* ISCSI_TGT_OID_LIST - iscsiadm list target */
2188 		case ISCSI_TGT_OID_LIST:
2189 
2190 			/* get sessions from hba's session list */
2191 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2192 			for (isp = ihp->hba_sess_list; isp;
2193 			    isp = isp->sess_next) {
2194 
2195 				if (((isp->sess_state !=
2196 				    ISCSI_SESS_STATE_FREE) ||
2197 				    (isp->sess_discovered_by !=
2198 				    iSCSIDiscoveryMethodUnknown)) &&
2199 				    (isp->sess_type ==
2200 				    ISCSI_SESS_TYPE_NORMAL)) {
2201 					if (idlp->tl_out_cnt <
2202 					    idlp->tl_in_cnt) {
2203 						idlp->tl_oid_list[
2204 						    idlp->tl_out_cnt] =
2205 						    isp->sess_oid;
2206 					}
2207 					idlp->tl_out_cnt++;
2208 				}
2209 
2210 			}
2211 			rw_exit(&ihp->hba_sess_list_rwlock);
2212 			break;
2213 
2214 		default:
2215 			ASSERT(FALSE);
2216 		}
2217 
2218 		rtn = ddi_copyout(idlp, (caddr_t)arg, list_space, mode);
2219 		kmem_free(idlp, list_space);
2220 		break;
2221 
2222 	/*
2223 	 * ISCSI_TARGET_PROPS_GET -
2224 	 */
2225 	case ISCSI_TARGET_PROPS_GET:
2226 		/* ---- fall through sense the code is almost the same ---- */
2227 
2228 	/*
2229 	 * ISCSI_TARGET_PROPS_SET -
2230 	 */
2231 	case ISCSI_TARGET_PROPS_SET:
2232 		/* copyin user args */
2233 		ipp = (iscsi_property_t *)kmem_alloc(sizeof (*ipp),
2234 		    KM_SLEEP);
2235 		if (ddi_copyin((caddr_t)arg, ipp, sizeof (*ipp), mode)) {
2236 			rtn = EFAULT;
2237 			kmem_free(ipp, sizeof (*ipp));
2238 			break;
2239 		}
2240 
2241 		if (ipp->p_vers != ISCSI_INTERFACE_VERSION) {
2242 			rtn = EINVAL;
2243 			kmem_free(ipp, sizeof (*ipp));
2244 			break;
2245 		}
2246 
2247 		rtn = iscsi_target_prop_mod(ihp, ipp, cmd);
2248 		if (rtn == 0)
2249 			rtn = ddi_copyout(ipp, (caddr_t)arg,
2250 			    sizeof (*ipp), mode);
2251 		kmem_free(ipp, sizeof (*ipp));
2252 		break;
2253 
2254 	/*
2255 	 * ISCSI_TARGET_ADDRESS_GET -
2256 	 */
2257 	case ISCSI_TARGET_ADDRESS_GET:
2258 		if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) {
2259 			rtn = EFAULT;
2260 			break;
2261 		}
2262 
2263 		if (ial.al_vers != ISCSI_INTERFACE_VERSION) {
2264 			rtn = EINVAL;
2265 			break;
2266 		}
2267 
2268 		/*
2269 		 * Find out how much space we need to malloc for the users
2270 		 * request.
2271 		 */
2272 		list_space = sizeof (iscsi_addr_list_t);
2273 		if (ial.al_in_cnt != 0) {
2274 			list_space += (sizeof (iscsi_addr_t) *
2275 			    (ial.al_in_cnt - 1));
2276 		}
2277 		ialp = (iscsi_addr_list_t *)kmem_zalloc(list_space, KM_SLEEP);
2278 
2279 		/* Copy in the header portion */
2280 		bcopy(&ial, ialp, sizeof (ial));
2281 
2282 		/* session */
2283 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2284 		rtn = iscsi_sess_get(ialp->al_oid, ihp, &isp);
2285 		if (rtn != 0) {
2286 			rw_exit(&ihp->hba_sess_list_rwlock);
2287 			rtn = EFAULT;
2288 			break;
2289 		}
2290 
2291 		ialp->al_out_cnt	= 0;
2292 		ialp->al_tpgt		= isp->sess_tpgt_conf;
2293 		rw_enter(&isp->sess_conn_list_rwlock, RW_READER);
2294 		for (icp = isp->sess_conn_list; icp; icp = icp->conn_next) {
2295 			if (icp->conn_state != ISCSI_CONN_STATE_LOGGED_IN) {
2296 				continue;
2297 			}
2298 			if (ialp->al_out_cnt < ialp->al_in_cnt) {
2299 				iscsi_addr_t		*ap;
2300 
2301 				ap = &ialp->al_addrs[ialp->al_out_cnt];
2302 				if (icp->conn_base_addr.sin.sa_family
2303 				    == AF_INET) {
2304 
2305 					struct sockaddr_in *addr_in =
2306 					    (struct sockaddr_in *)&icp->
2307 					    conn_base_addr.sin4;
2308 					ap->a_addr.i_insize =
2309 					    sizeof (struct in_addr);
2310 					bcopy(&addr_in->sin_addr.s_addr,
2311 					    &ap->a_addr.i_addr.in4.s_addr,
2312 					    sizeof (struct in_addr));
2313 					ap->a_port = addr_in->sin_port;
2314 
2315 				} else {
2316 
2317 					struct sockaddr_in6 *addr_in6 =
2318 					    (struct sockaddr_in6 *)&icp->
2319 					    conn_base_addr.sin6;
2320 					ap->a_addr.i_insize =
2321 					    sizeof (struct in6_addr);
2322 					bcopy(&addr_in6->sin6_addr.s6_addr,
2323 					    &ap->a_addr.i_addr.in6.s6_addr,
2324 					    sizeof (struct in6_addr));
2325 					ap->a_port = addr_in6->sin6_port;
2326 
2327 				}
2328 			}
2329 			ialp->al_out_cnt++;
2330 		}
2331 		rw_exit(&isp->sess_conn_list_rwlock);
2332 		rw_exit(&ihp->hba_sess_list_rwlock);
2333 
2334 		rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode);
2335 		kmem_free(ialp, list_space);
2336 		break;
2337 
2338 	/*
2339 	 * ISCSI_CHAP_SET -
2340 	 */
2341 	case ISCSI_CHAP_SET:
2342 		chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap),
2343 		    KM_SLEEP);
2344 		if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) {
2345 			rtn = EFAULT;
2346 			kmem_free(chap, sizeof (*chap));
2347 			break;
2348 		} else if (chap->c_vers != ISCSI_INTERFACE_VERSION) {
2349 			rtn = EINVAL;
2350 			kmem_free(chap, sizeof (*chap));
2351 			break;
2352 		}
2353 
2354 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2355 		if (chap->c_oid == ihp->hba_oid)
2356 			name = ihp->hba_name;
2357 		else {
2358 			rtn = iscsi_sess_get(chap->c_oid, ihp, &isp);
2359 			if (rtn != 0) {
2360 				rtn = iscsi_sess_get_by_target(
2361 				    chap->c_oid, ihp, &isp);
2362 			}
2363 
2364 			/*
2365 			 * If rtn is zero then we have found an
2366 			 * existing session.  Use the session name to
2367 			 * do param lookup.  If rtn is non-zero then
2368 			 * create a targetparam object and use its name
2369 			 * for param lookup.
2370 			 */
2371 			if (rtn == 0) {
2372 				name = isp->sess_name;
2373 			} else {
2374 				name =
2375 				    iscsi_targetparam_get_name(chap->c_oid);
2376 				rtn = 0;
2377 			}
2378 		}
2379 
2380 		if (name == NULL) {
2381 			rw_exit(
2382 			    &ihp->hba_sess_list_rwlock);
2383 			rtn = EFAULT;
2384 			kmem_free(chap, sizeof (*chap));
2385 			break;
2386 		}
2387 
2388 		if (persistent_chap_set((char *)name, chap) ==
2389 		    B_FALSE) {
2390 			rtn = EIO;
2391 		}
2392 		rw_exit(&ihp->hba_sess_list_rwlock);
2393 		kmem_free(chap, sizeof (*chap));
2394 		break;
2395 
2396 	/*
2397 	 * ISCSI_CHAP_GET -
2398 	 */
2399 	case ISCSI_CHAP_GET:
2400 		chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap),
2401 		    KM_SLEEP);
2402 		if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) {
2403 			kmem_free(chap, sizeof (*chap));
2404 			rtn = EFAULT;
2405 			break;
2406 		} else if (chap->c_vers != ISCSI_INTERFACE_VERSION) {
2407 			kmem_free(chap, sizeof (*chap));
2408 			rtn = EINVAL;
2409 			break;
2410 		}
2411 
2412 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2413 		if (chap->c_oid == ihp->hba_oid)
2414 			name = ihp->hba_name;
2415 		else {
2416 			rtn = iscsi_sess_get(chap->c_oid, ihp, &isp);
2417 			if (rtn != 0) {
2418 				rtn = iscsi_sess_get_by_target(
2419 				    chap->c_oid, ihp, &isp);
2420 			}
2421 
2422 			/*
2423 			 * If rtn is zero then we have found an
2424 			 * existing session.  Use the session name to
2425 			 * do param lookup.  If rtn is non-zero then
2426 			 * create a targetparam object and use its name
2427 			 * for param lookup.
2428 			 */
2429 			if (rtn == 0) {
2430 				name = isp->sess_name;
2431 			} else {
2432 				rtn = 0;
2433 				name =
2434 				    iscsi_targetparam_get_name(chap->c_oid);
2435 			}
2436 
2437 			if (name == NULL) {
2438 				rw_exit(&ihp->hba_sess_list_rwlock);
2439 				rtn = EFAULT;
2440 				break;
2441 			}
2442 			/*
2443 			 * Initialize the target-side chap name to the
2444 			 * session name if no chap settings have been
2445 			 * saved for the current session.
2446 			 */
2447 			if (persistent_chap_get((char *)name,
2448 			    chap) == B_FALSE) {
2449 				int name_len = strlen((char *)name);
2450 				iscsi_chap_props_t *chap = NULL;
2451 				chap = (iscsi_chap_props_t *)kmem_zalloc
2452 				    (sizeof (iscsi_chap_props_t), KM_SLEEP);
2453 				bcopy((char *)name, chap->c_user, name_len);
2454 				chap->c_user_len = name_len;
2455 				(void) (persistent_chap_set((char *)name,
2456 				    chap));
2457 				kmem_free(chap, sizeof (*chap));
2458 			}
2459 		}
2460 
2461 		if (name == NULL) {
2462 			rw_exit(
2463 			    &ihp->hba_sess_list_rwlock);
2464 			rtn = EFAULT;
2465 			break;
2466 		}
2467 
2468 		if (persistent_chap_get((char *)name, chap) == B_FALSE) {
2469 			rw_exit(&ihp->hba_sess_list_rwlock);
2470 			rtn = EIO;
2471 			break;
2472 		}
2473 		rw_exit(&ihp->hba_sess_list_rwlock);
2474 
2475 		rtn = ddi_copyout(chap, (caddr_t)arg, sizeof (*chap), mode);
2476 		kmem_free(chap, sizeof (*chap));
2477 		break;
2478 
2479 	/*
2480 	 * ISCSI_CHAP_CLEAR -
2481 	 */
2482 	case ISCSI_CHAP_CLEAR:
2483 		chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap),
2484 		    KM_SLEEP);
2485 		if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) {
2486 			rtn = EFAULT;
2487 			kmem_free(chap, sizeof (*chap));
2488 			break;
2489 		} else if (chap->c_vers != ISCSI_INTERFACE_VERSION) {
2490 			rtn = EINVAL;
2491 			kmem_free(chap, sizeof (*chap));
2492 			break;
2493 		}
2494 
2495 		if (chap->c_oid == ihp->hba_oid) {
2496 			iscsi_sess_t *sessp;
2497 
2498 			name = ihp->hba_name;
2499 
2500 			if (persistent_chap_clear(
2501 			    (char *)name) == B_FALSE) {
2502 				rtn = EIO;
2503 			}
2504 
2505 			/*
2506 			 * Loop through all sessions and memset their
2507 			 * (initiator's) passwords
2508 			 */
2509 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2510 			for (sessp = ihp->hba_sess_list; sessp;
2511 			    sessp = sessp->sess_next) {
2512 				(void) memset(sessp->sess_auth.password,
2513 				    0, iscsiAuthStringMaxLength);
2514 				sessp->sess_auth.password_length = 0;
2515 			}
2516 			rw_exit(&ihp->hba_sess_list_rwlock);
2517 
2518 		} else {
2519 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
2520 			/*
2521 			 * If the oid does represent a session check to see
2522 			 * if it is a target oid.  If so, return the target's
2523 			 * associated session.
2524 			 */
2525 			rtn = iscsi_sess_get(chap->c_oid, ihp, &isp);
2526 			if (rtn != 0) {
2527 				rtn = iscsi_sess_get_by_target(chap->c_oid,
2528 				    ihp, &isp);
2529 			}
2530 
2531 			rw_exit(&ihp->hba_sess_list_rwlock);
2532 
2533 			/*
2534 			 * If rtn is zero then we have found an
2535 			 * existing session.  Use the session name to
2536 			 * do param lookup.  If rtn is non-zero then
2537 			 * create a targetparam object and use its name
2538 			 * for param lookup.
2539 			 */
2540 			if (rtn == 0) {
2541 				name = isp->sess_name;
2542 			} else {
2543 				name =
2544 				    iscsi_targetparam_get_name(chap->c_oid);
2545 				rtn = 0;
2546 			}
2547 
2548 			if (name == NULL) {
2549 				rtn = EFAULT;
2550 				break;
2551 			}
2552 
2553 			if (persistent_chap_clear(
2554 			    (char *)name) == B_FALSE) {
2555 				rtn = EIO;
2556 			}
2557 
2558 			/*
2559 			 * Clear out session chap password if we found a
2560 			 * session above.
2561 			 */
2562 			if (isp != NULL) {
2563 				(void) memset(isp->sess_auth.password_in,
2564 				    0, iscsiAuthStringMaxLength);
2565 				isp->sess_auth.password_length_in = 0;
2566 			}
2567 
2568 		}
2569 
2570 		kmem_free(chap, sizeof (*chap));
2571 		break;
2572 
2573 	/*
2574 	 * ISCSI_STATIC_GET -
2575 	 */
2576 	case ISCSI_STATIC_GET:
2577 		ispp = (iscsi_static_property_t *)kmem_alloc(
2578 		    sizeof (*ispp), KM_SLEEP);
2579 
2580 		if (ddi_copyin((caddr_t)arg, ispp, sizeof (*ispp), mode)) {
2581 			rtn = EFAULT;
2582 			kmem_free(ispp, sizeof (*ispp));
2583 			break;
2584 		}
2585 
2586 		if (ispp->p_vers != ISCSI_INTERFACE_VERSION) {
2587 			rtn = EINVAL;
2588 			kmem_free(ispp, sizeof (*ispp));
2589 			break;
2590 		}
2591 
2592 		{
2593 			void *v = NULL;
2594 			boolean_t found = B_FALSE;
2595 
2596 			persistent_static_addr_lock();
2597 			while (persistent_static_addr_next(&v,
2598 			    (char *)ispp->p_name, &e) == B_TRUE) {
2599 
2600 				if (ispp->p_oid == e.e_oid) {
2601 					/*
2602 					 * In case there are multiple
2603 					 * addresses associated with the
2604 					 * given target OID, pick the first
2605 					 * one.
2606 					 */
2607 					iscsi_addr_t *ap;
2608 
2609 					ap = &(ispp->p_addr_list.al_addrs[0]);
2610 					ap->a_port = e.e_port;
2611 					ap->a_addr.i_insize = e.e_insize;
2612 					bcopy(e.e_u.u_in6.s6_addr,
2613 					    ap->a_addr.i_addr.in6.s6_addr,
2614 					    e.e_insize);
2615 					ispp->p_name_len =
2616 					    strlen((char *)ispp->p_name);
2617 					ispp->p_addr_list.al_tpgt = e.e_tpgt;
2618 					ispp->p_addr_list.al_out_cnt = 1;
2619 
2620 					found = B_TRUE;
2621 					break;
2622 				}
2623 			}
2624 			persistent_static_addr_unlock();
2625 
2626 			if (found == B_TRUE) {
2627 				rtn = ddi_copyout(ispp, (caddr_t)arg,
2628 				    sizeof (*ispp), mode);
2629 			} else {
2630 				rtn = ENOENT;
2631 			}
2632 		}
2633 		kmem_free(ispp, sizeof (*ispp));
2634 
2635 		break;
2636 
2637 	/*
2638 	 * ISCSI_STATIC_SET -
2639 	 */
2640 	case ISCSI_STATIC_SET:
2641 		target = iscsi_ioctl_copyin((caddr_t)arg, mode,
2642 		    sizeof (*target));
2643 		if (target == NULL) {
2644 			rtn = EFAULT;
2645 			break;
2646 		}
2647 
2648 		if ((target->te_entry.e_vers != ISCSI_INTERFACE_VERSION) ||
2649 		    (target->te_entry.e_insize == 0)) {
2650 			kmem_free(target, sizeof (*target));
2651 			rtn = EINVAL;
2652 			break;
2653 		}
2654 
2655 		/* Check if the target's already been added */
2656 		{
2657 			boolean_t static_target_found = B_FALSE;
2658 			void *v = NULL;
2659 
2660 			name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
2661 			persistent_static_addr_lock();
2662 			while (persistent_static_addr_next(&v, (char *)name,
2663 			    &e) == B_TRUE) {
2664 				/*
2665 				 * MC/S - Need to check IP address and port
2666 				 * number as well when we support MC/S.
2667 				 */
2668 				if ((strncmp((char *)name,
2669 				    (char *)target->te_name,
2670 				    ISCSI_MAX_NAME_LEN) == 0) &&
2671 				    (target->te_entry.e_tpgt == e.e_tpgt) &&
2672 				    (target->te_entry.e_insize == e.e_insize) &&
2673 				    (bcmp(&target->te_entry.e_u, &e.e_u,
2674 				    e.e_insize) == 0)) {
2675 					/*
2676 					 * We don't allow MC/S for now but
2677 					 * we do allow adding the same target
2678 					 * with different TPGTs (hence,
2679 					 * different sessions).
2680 					 */
2681 					static_target_found = B_TRUE;
2682 					break;
2683 				}
2684 			}
2685 			persistent_static_addr_unlock();
2686 			kmem_free(name, ISCSI_MAX_NAME_LEN);
2687 
2688 			if (static_target_found == B_TRUE) {
2689 				/* Duplicate entry */
2690 				kmem_free(target, sizeof (*target));
2691 				rtn = EEXIST;
2692 				break;
2693 			}
2694 		}
2695 
2696 		if (target->te_entry.e_oid == ISCSI_OID_NOTSET) {
2697 			mutex_enter(&iscsi_oid_mutex);
2698 			target->te_entry.e_oid = iscsi_oid++;
2699 			mutex_exit(&iscsi_oid_mutex);
2700 		}
2701 
2702 		persistent_static_addr_lock();
2703 		if (persistent_static_addr_set((char *)target->te_name,
2704 		    &target->te_entry) == B_FALSE) {
2705 			persistent_static_addr_unlock();
2706 			kmem_free(target, sizeof (*target));
2707 			rtn = EIO;
2708 			break;
2709 		}
2710 		persistent_static_addr_unlock();
2711 
2712 		/*
2713 		 * If Static Targets discovery is enabled, then add
2714 		 * target to discovery queue. Otherwise, just create
2715 		 * the session for potential future use.
2716 		 */
2717 		method = persistent_disc_meth_get();
2718 		if (method & iSCSIDiscoveryMethodStatic) {
2719 			iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodStatic);
2720 			(void) iscsid_login_tgt(ihp, (char *)target->te_name,
2721 			    iSCSIDiscoveryMethodStatic, NULL);
2722 		}
2723 
2724 		rtn = iscsi_ioctl_copyout(target, sizeof (*target),
2725 		    (caddr_t)arg, mode);
2726 		break;
2727 
2728 	/*
2729 	 * ISCSI_STATIC_CLEAR -
2730 	 */
2731 	case ISCSI_STATIC_CLEAR:
2732 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
2733 			rtn = EFAULT;
2734 			break;
2735 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
2736 			rtn = EINVAL;
2737 			break;
2738 		}
2739 
2740 		{
2741 			boolean_t	found = B_FALSE;
2742 			void		*v = NULL;
2743 			entry_t		tmp_e;
2744 			char		*name = NULL;
2745 
2746 			name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
2747 
2748 			/* Find name for matching static_tgt oid */
2749 			persistent_static_addr_lock();
2750 			while (persistent_static_addr_next(&v,
2751 			    (char *)name, &tmp_e) == B_TRUE) {
2752 				if (e.e_oid == tmp_e.e_oid) {
2753 					found = B_TRUE;
2754 					break;
2755 				}
2756 			}
2757 
2758 			/* If static_tgt found logout and remove it */
2759 			if (found == B_TRUE) {
2760 
2761 				iscsid_addr_to_sockaddr(tmp_e.e_insize,
2762 				    &tmp_e.e_u, tmp_e.e_port, &addr_dsc.sin);
2763 
2764 				persistent_static_addr_unlock();
2765 
2766 				/*
2767 				 * If discovery in progress, try few times
2768 				 * before return busy
2769 				 */
2770 				retry = 0;
2771 				mutex_enter(&ihp->hba_discovery_events_mutex);
2772 				while (ihp->hba_discovery_in_progress ==
2773 				    B_TRUE) {
2774 					if (++retry == 5) {
2775 						rtn = EBUSY;
2776 						break;
2777 					}
2778 					mutex_exit(
2779 					    &ihp->hba_discovery_events_mutex);
2780 					delay(SEC_TO_TICK(
2781 					    ISCSI_DISC_DELAY));
2782 					mutex_enter(
2783 					    &ihp->hba_discovery_events_mutex);
2784 				}
2785 				/* remove from persistent store */
2786 				if (rtn == 0 && persistent_static_addr_clear(
2787 				    e.e_oid) == B_FALSE) {
2788 					rtn = EIO;
2789 				}
2790 				mutex_exit(&ihp->hba_discovery_events_mutex);
2791 
2792 				if (rtn != 0) {
2793 					kmem_free(name, ISCSI_MAX_NAME_LEN);
2794 					break;
2795 				}
2796 
2797 				/* Attempt to logout of target */
2798 				if (iscsid_del(ihp, (char *)name,
2799 				    iSCSIDiscoveryMethodStatic, &addr_dsc.sin)
2800 				    == B_FALSE) {
2801 					persistent_static_addr_lock();
2802 
2803 					/*
2804 					 * Restore static_tgt to
2805 					 * persistent store
2806 					 */
2807 					if (persistent_static_addr_set(
2808 					    (char *)name,
2809 					    &tmp_e) == B_FALSE) {
2810 						cmn_err(CE_WARN, "Failed to "
2811 						    "restore static target "
2812 						    "address after logout "
2813 						    "target failure.");
2814 					}
2815 					persistent_static_addr_unlock();
2816 					rtn = EBUSY;
2817 				} else {
2818 					iscsid_poke_discovery(ihp,
2819 					    iSCSIDiscoveryMethodStatic);
2820 					(void) iscsid_login_tgt(ihp,
2821 					    (char *)name,
2822 					    iSCSIDiscoveryMethodStatic,
2823 					    NULL);
2824 
2825 				}
2826 			} else {
2827 				persistent_static_addr_unlock();
2828 				rtn = EIO;
2829 			}
2830 			kmem_free(name, ISCSI_MAX_NAME_LEN);
2831 		}
2832 		break;
2833 
2834 	/*
2835 	 * ISCSI_ISNS_SERVER_ADDR_SET:
2836 	 */
2837 	case ISCSI_ISNS_SERVER_ADDR_SET:
2838 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
2839 			rtn = EFAULT;
2840 			break;
2841 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
2842 			rtn = EINVAL;
2843 			break;
2844 		}
2845 
2846 		if (persistent_isns_addr_set(&e) == B_FALSE) {
2847 			rtn = EIO;
2848 			break;
2849 		}
2850 
2851 		/*
2852 		 * If iSNS server discovery is enabled, then kickoff
2853 		 * discovery of the targets advertised by the recently
2854 		 * added iSNS server address.
2855 		 */
2856 		method = persistent_disc_meth_get();
2857 		if (method & iSCSIDiscoveryMethodISNS) {
2858 			initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN,
2859 			    KM_SLEEP);
2860 			if (persistent_initiator_name_get(initiator_node_name,
2861 			    ISCSI_MAX_NAME_LEN) != B_TRUE) {
2862 				kmem_free(initiator_node_name,
2863 				    ISCSI_MAX_NAME_LEN);
2864 				initiator_node_name = NULL;
2865 				rtn = EIO;
2866 				break;
2867 			}
2868 			if (strlen(initiator_node_name) == 0) {
2869 				kmem_free(initiator_node_name,
2870 				    ISCSI_MAX_NAME_LEN);
2871 				initiator_node_name = NULL;
2872 				rtn = EIO;
2873 				break;
2874 			}
2875 
2876 			initiator_node_alias = kmem_zalloc(ISCSI_MAX_NAME_LEN,
2877 			    KM_SLEEP);
2878 			if (persistent_alias_name_get(initiator_node_alias,
2879 			    ISCSI_MAX_NAME_LEN) != B_TRUE) {
2880 				initiator_node_alias[0] = '\0';
2881 			}
2882 
2883 			/*
2884 			 * Register this initiator node against this iSNS
2885 			 * server.
2886 			 */
2887 			(void) isns_reg_one_server(&e, ihp->hba_isid,
2888 			    (uint8_t *)initiator_node_name,
2889 			    ISCSI_MAX_NAME_LEN,
2890 			    (uint8_t *)initiator_node_alias,
2891 			    ISCSI_MAX_NAME_LEN,
2892 			    ISNS_INITIATOR_NODE_TYPE,
2893 			    isns_scn_callback);
2894 
2895 			iscsid_do_isns_query_one_server(ihp, &e);
2896 
2897 			iscsid_addr_to_sockaddr(e.e_insize,
2898 			    &e.e_u, e.e_port, &addr_dsc.sin);
2899 
2900 			(void) iscsid_login_tgt(ihp, NULL,
2901 			    iSCSIDiscoveryMethodISNS,
2902 			    &addr_dsc.sin);
2903 
2904 			/* Done using the name and alias - free them. */
2905 			kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
2906 			initiator_node_name = NULL;
2907 			kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN);
2908 			initiator_node_alias = NULL;
2909 		}
2910 		break;
2911 
2912 	/*
2913 	 * ISCSI_DISCOVERY_ADDR_SET:
2914 	 */
2915 	case ISCSI_DISCOVERY_ADDR_SET:
2916 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
2917 			rtn = EFAULT;
2918 			break;
2919 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
2920 			rtn = EINVAL;
2921 			break;
2922 		}
2923 
2924 		if (e.e_oid == ISCSI_OID_NOTSET) {
2925 			mutex_enter(&iscsi_oid_mutex);
2926 			e.e_oid = iscsi_oid++;
2927 			mutex_exit(&iscsi_oid_mutex);
2928 		}
2929 
2930 		if (persistent_disc_addr_set(&e) == B_FALSE) {
2931 			rtn = EIO;
2932 			break;
2933 		}
2934 
2935 		/*
2936 		 * If Send Targets discovery is enabled, then kickoff
2937 		 * discovery of the targets advertised by the recently
2938 		 * added discovery address.
2939 		 */
2940 		method = persistent_disc_meth_get();
2941 		if (method & iSCSIDiscoveryMethodSendTargets) {
2942 
2943 			iscsid_addr_to_sockaddr(e.e_insize,
2944 			    &e.e_u, e.e_port, &addr_dsc.sin);
2945 			iscsid_do_sendtgts(&e);
2946 			(void) iscsid_login_tgt(ihp, NULL,
2947 			    iSCSIDiscoveryMethodSendTargets,
2948 			    &addr_dsc.sin);
2949 
2950 		}
2951 		break;
2952 
2953 	/*
2954 	 * ISCSI_DISCOVERY_ADDR_LIST_GET
2955 	 */
2956 	case ISCSI_DISCOVERY_ADDR_LIST_GET:
2957 		/* copyin user args */
2958 		if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) {
2959 			rtn = EFAULT;
2960 			break;
2961 		}
2962 
2963 		if (ial.al_vers != ISCSI_INTERFACE_VERSION) {
2964 			rtn = EINVAL;
2965 			break;
2966 		}
2967 
2968 		list_space = sizeof (iscsi_addr_list_t);
2969 		if (ial.al_in_cnt != 0) {
2970 			list_space += (sizeof (iscsi_addr_t) *
2971 			    (ial.al_in_cnt - 1));
2972 		}
2973 
2974 		ialp = kmem_zalloc(list_space, KM_SLEEP);
2975 		bcopy(&ial, ialp, sizeof (iscsi_addr_list_t));
2976 
2977 		void_p = NULL;
2978 		ialp->al_out_cnt = 0;
2979 		persistent_disc_addr_lock();
2980 		while (persistent_disc_addr_next(&void_p, &e) == B_TRUE) {
2981 			if (ialp->al_out_cnt < ialp->al_in_cnt) {
2982 				int		i = ialp->al_out_cnt;
2983 				iscsi_addr_t	*addr = &ialp->al_addrs[i];
2984 
2985 				addr->a_port = e.e_port;
2986 				addr->a_addr.i_insize = e.e_insize;
2987 				addr->a_oid = e.e_oid;
2988 
2989 				if (e.e_insize == sizeof (struct in_addr)) {
2990 					/* IPv4 */
2991 					addr->a_addr.i_addr.in4.s_addr =
2992 					    e.e_u.u_in4.s_addr;
2993 				} else if (e.e_insize ==
2994 					    sizeof (struct in6_addr)) {
2995 					/* IPv6 */
2996 					bcopy(e.e_u.u_in6.s6_addr,
2997 					    addr->a_addr.i_addr.in6.s6_addr,
2998 					    16);
2999 				}
3000 			}
3001 			ialp->al_out_cnt++;
3002 		}
3003 		persistent_disc_addr_unlock();
3004 
3005 		rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode);
3006 		kmem_free(ialp, list_space);
3007 		break;
3008 
3009 	/*
3010 	 * ISCSI_ISNS_SERVER_ADDR_LIST_GET
3011 	 */
3012 	case ISCSI_ISNS_SERVER_ADDR_LIST_GET:
3013 		/* copyin user args */
3014 		if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) {
3015 			rtn = EFAULT;
3016 			break;
3017 		}
3018 
3019 		if (ial.al_vers != ISCSI_INTERFACE_VERSION) {
3020 			rtn = EINVAL;
3021 			break;
3022 		}
3023 
3024 		list_space = sizeof (iscsi_addr_list_t);
3025 		if (ial.al_in_cnt != 0) {
3026 			list_space += (sizeof (iscsi_addr_t) *
3027 			    (ial.al_in_cnt - 1));
3028 		}
3029 
3030 		ialp = kmem_zalloc(list_space, KM_SLEEP);
3031 		bcopy(&ial, ialp, sizeof (iscsi_addr_list_t));
3032 
3033 		void_p = NULL;
3034 		ialp->al_out_cnt = 0;
3035 		persistent_isns_addr_lock();
3036 		while (persistent_isns_addr_next(&void_p, &e) == B_TRUE) {
3037 			if (ialp->al_out_cnt < ialp->al_in_cnt) {
3038 				int		i = ialp->al_out_cnt;
3039 				iscsi_addr_t	*addr = &ialp->al_addrs[i];
3040 
3041 				addr->a_port = e.e_port;
3042 				addr->a_addr.i_insize = e.e_insize;
3043 				if (e.e_insize == sizeof (struct in_addr)) {
3044 					/* IPv4 */
3045 					addr->a_addr.i_addr.in4.s_addr =
3046 					    e.e_u.u_in4.s_addr;
3047 				} else if (e.e_insize ==
3048 					    sizeof (struct in6_addr)) {
3049 					/* IPv6 */
3050 					bcopy(e.e_u.u_in6.s6_addr,
3051 					    addr->a_addr.i_addr.in6.s6_addr,
3052 					    16);
3053 				}
3054 			}
3055 			ialp->al_out_cnt++;
3056 		}
3057 		persistent_isns_addr_unlock();
3058 
3059 		rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode);
3060 		kmem_free(ialp, list_space);
3061 		break;
3062 
3063 	/*
3064 	 * ISCSI_DISCOVERY_ADDR_CLEAR:
3065 	 */
3066 	case ISCSI_DISCOVERY_ADDR_CLEAR:
3067 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
3068 			rtn = EFAULT;
3069 			break;
3070 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
3071 			rtn = EINVAL;
3072 			break;
3073 		}
3074 
3075 		iscsid_addr_to_sockaddr(e.e_insize,
3076 		    &e.e_u, e.e_port, &addr_dsc.sin);
3077 
3078 		/* If discovery in progress, try few times before return busy */
3079 		retry = 0;
3080 		mutex_enter(&ihp->hba_discovery_events_mutex);
3081 		while (ihp->hba_discovery_in_progress == B_TRUE) {
3082 			if (++retry == 5) {
3083 				rtn = EBUSY;
3084 				break;
3085 			}
3086 			mutex_exit(&ihp->hba_discovery_events_mutex);
3087 			delay(SEC_TO_TICK(ISCSI_DISC_DELAY));
3088 			mutex_enter(&ihp->hba_discovery_events_mutex);
3089 		}
3090 
3091 		/*
3092 		 * Clear discovery address first, so that any bus config
3093 		 * will ignore this discovery address
3094 		 */
3095 		if (rtn == 0 && persistent_disc_addr_clear(&e) == B_FALSE) {
3096 			rtn = EIO;
3097 		}
3098 		mutex_exit(&ihp->hba_discovery_events_mutex);
3099 
3100 		if (rtn != 0) {
3101 			break;
3102 		}
3103 		/* Attempt to logout of associated targets */
3104 		if (iscsid_del(ihp, NULL,
3105 		    iSCSIDiscoveryMethodSendTargets, &addr_dsc.sin) ==
3106 		    B_FALSE) {
3107 			/* Failure!, restore the discovery addr. */
3108 			if (persistent_disc_addr_set(&e) == B_FALSE) {
3109 				cmn_err(CE_WARN, "Failed to restore sendtgt "
3110 				    "discovery address after logout associated "
3111 				    "targets failures.");
3112 			}
3113 			rtn = EBUSY;
3114 		}
3115 		break;
3116 
3117 	/*
3118 	 * ISCSI_ISNS_SERVER_CLEAR:
3119 	 */
3120 	case ISCSI_ISNS_SERVER_ADDR_CLEAR:
3121 		if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) {
3122 			rtn = EFAULT;
3123 			break;
3124 		} else if (e.e_vers != ISCSI_INTERFACE_VERSION) {
3125 			rtn = EINVAL;
3126 			break;
3127 		}
3128 
3129 		iscsid_addr_to_sockaddr(e.e_insize,
3130 		    &e.e_u, e.e_port, &addr_dsc.sin);
3131 
3132 		/* If discovery in progress, try few times before return busy */
3133 		retry = 0;
3134 		mutex_enter(&ihp->hba_discovery_events_mutex);
3135 		while (ihp->hba_discovery_in_progress == B_TRUE) {
3136 			if (++retry == 5) {
3137 				rtn = EBUSY;
3138 				break;
3139 			}
3140 			mutex_exit(&ihp->hba_discovery_events_mutex);
3141 			delay(SEC_TO_TICK(ISCSI_DISC_DELAY));
3142 			mutex_enter(&ihp->hba_discovery_events_mutex);
3143 		}
3144 
3145 		/*
3146 		 * Clear isns server address first, so that any bus config
3147 		 * will ignore any target registerd on this isns server
3148 		 */
3149 		if (rtn == 0 && persistent_isns_addr_clear(&e) == B_FALSE) {
3150 			rtn = EIO;
3151 		}
3152 		mutex_exit(&ihp->hba_discovery_events_mutex);
3153 
3154 		if (rtn != 0) {
3155 			break;
3156 		}
3157 
3158 		/* Attempt logout of associated targets */
3159 		if (iscsid_del(ihp, NULL, iSCSIDiscoveryMethodISNS,
3160 		    &addr_dsc.sin) == B_FALSE) {
3161 			/* Failure!, restore the isns server addr. */
3162 
3163 			if (persistent_isns_addr_set(&e) == B_FALSE) {
3164 				cmn_err(CE_WARN, "Failed to restore isns server"
3165 				    " address after logout associated targets"
3166 				    " failures.");
3167 			}
3168 			rtn = EBUSY;
3169 		} else {
3170 			method = persistent_disc_meth_get();
3171 			if (method & iSCSIDiscoveryMethodISNS) {
3172 				boolean_t is_last_isns_server_b =
3173 				    B_FALSE;
3174 				int isns_server_count = 0;
3175 				void *void_p = NULL;
3176 
3177 				/*
3178 				 * Check if the last iSNS server's been
3179 				 * removed.
3180 				 */
3181 				{
3182 					entry_t tmp_e;
3183 					persistent_isns_addr_lock();
3184 					while (persistent_isns_addr_next(
3185 					    &void_p, &tmp_e) == B_TRUE) {
3186 						isns_server_count++;
3187 					}
3188 				}
3189 				persistent_isns_addr_unlock();
3190 				if (isns_server_count == 0) {
3191 					is_last_isns_server_b = B_TRUE;
3192 				}
3193 
3194 				/*
3195 				 * Deregister this node from this iSNS
3196 				 * server.
3197 				 */
3198 				initiator_node_name = kmem_zalloc(
3199 				    ISCSI_MAX_NAME_LEN, KM_SLEEP);
3200 				if (persistent_initiator_name_get(
3201 				    initiator_node_name,
3202 				    ISCSI_MAX_NAME_LEN) == B_TRUE) {
3203 
3204 					if (strlen(initiator_node_name) > 0) {
3205 						(void) isns_dereg_one_server(
3206 						    &e, (uint8_t *)
3207 						    initiator_node_name,
3208 						    is_last_isns_server_b);
3209 					}
3210 				}
3211 				kmem_free(initiator_node_name,
3212 				    ISCSI_MAX_NAME_LEN);
3213 				initiator_node_name = NULL;
3214 			}
3215 		}
3216 		break;
3217 
3218 	/*
3219 	 * ISCSI_DISCOVERY_SET -
3220 	 */
3221 	case ISCSI_DISCOVERY_SET:
3222 		if (ddi_copyin((caddr_t)arg, &method, sizeof (method), mode)) {
3223 			rtn = EFAULT;
3224 			break;
3225 		}
3226 
3227 		if (persistent_disc_meth_set(method) == B_FALSE) {
3228 			rtn = EIO;
3229 		} else {
3230 			(void) iscsid_enable_discovery(ihp, method, B_FALSE);
3231 			iscsid_poke_discovery(ihp, method);
3232 			(void) iscsid_login_tgt(ihp, NULL, method, NULL);
3233 		}
3234 		break;
3235 
3236 	/*
3237 	 * ISCSI_DISCOVERY_GET -
3238 	 */
3239 	case ISCSI_DISCOVERY_GET:
3240 		method = persistent_disc_meth_get();
3241 		rtn = ddi_copyout(&method, (caddr_t)arg,
3242 		    sizeof (method), mode);
3243 		break;
3244 
3245 	/*
3246 	 * ISCSI_DISCOVERY_CLEAR -
3247 	 */
3248 	case ISCSI_DISCOVERY_CLEAR:
3249 		if (ddi_copyin((caddr_t)arg, &method, sizeof (method), mode)) {
3250 			rtn = EFAULT;
3251 			break;
3252 		}
3253 
3254 		/* If discovery in progress, try few times before return busy */
3255 		retry = 0;
3256 		mutex_enter(&ihp->hba_discovery_events_mutex);
3257 		while (ihp->hba_discovery_in_progress == B_TRUE) {
3258 			if (++retry == 5) {
3259 				rtn = EBUSY;
3260 				break;
3261 			}
3262 			mutex_exit(&ihp->hba_discovery_events_mutex);
3263 			delay(SEC_TO_TICK(ISCSI_DISC_DELAY));
3264 			mutex_enter(&ihp->hba_discovery_events_mutex);
3265 		}
3266 
3267 		/*
3268 		 * Clear discovery first, so that any bus config or
3269 		 * discovery requests will ignore this discovery method
3270 		 */
3271 		if (rtn == 0 && persistent_disc_meth_clear(method) == B_FALSE) {
3272 			rtn = EIO;
3273 		}
3274 		mutex_exit(&ihp->hba_discovery_events_mutex);
3275 
3276 		if (rtn != 0) {
3277 			break;
3278 		}
3279 
3280 		/* Attempt to logout from all associated targets */
3281 		if (iscsid_disable_discovery(ihp, method) == B_FALSE) {
3282 			/* Failure!, reset the discovery */
3283 			if (persistent_disc_meth_set(method) == B_FALSE) {
3284 				cmn_err(CE_WARN, "Failed to reset discovery "
3285 				    "method after discovery disable failure.");
3286 			}
3287 			rtn = EBUSY;
3288 		}
3289 		break;
3290 
3291 	/*
3292 	 * ISCSI_DISCOVERY_PROPS -
3293 	 */
3294 	case ISCSI_DISCOVERY_PROPS:
3295 		iscsid_props(&discovery_props);
3296 		if (ddi_copyout(&discovery_props, (caddr_t)arg,
3297 		    sizeof (discovery_props), mode))
3298 			rtn = EFAULT;
3299 		break;
3300 
3301 	/*
3302 	 * ISCSI_LUN_OID_LIST --
3303 	 */
3304 	case ISCSI_LUN_OID_LIST_GET:
3305 		ll = (iscsi_lun_list_t *)kmem_alloc(sizeof (*ll), KM_SLEEP);
3306 		if (ddi_copyin((caddr_t)arg, ll, sizeof (*ll), mode)) {
3307 			rtn = EFAULT;
3308 			kmem_free(ll, sizeof (*ll));
3309 			break;
3310 		}
3311 
3312 		if (ll->ll_vers != ISCSI_INTERFACE_VERSION) {
3313 			rtn = EINVAL;
3314 			kmem_free(ll, sizeof (*ll));
3315 			break;
3316 		}
3317 
3318 		/*
3319 		 * Find out how much space the user has allocated in their
3320 		 * structure. Match the same space for our structure.
3321 		 */
3322 		lun_sz = sizeof (iscsi_lun_list_t);
3323 		if (ll->ll_in_cnt > 0) {
3324 			lun_sz += (ll->ll_in_cnt - 1) * sizeof (iscsi_if_lun_t);
3325 		}
3326 
3327 		llp = kmem_zalloc(lun_sz, KM_SLEEP);
3328 		bcopy(ll, llp, sizeof (*ll));
3329 		kmem_free(ll, sizeof (*ll));
3330 
3331 		/*
3332 		 * Check to see if oid references a target-param oid.  If so,
3333 		 * find the associated  session oid before getting lu list.
3334 		 */
3335 		if (iscsi_targetparam_get_name(llp->ll_tgt_oid) != NULL) {
3336 			for (isp = ihp->hba_sess_list; isp;
3337 			    isp = isp->sess_next) {
3338 				if (isp->sess_target_oid == llp->ll_tgt_oid) {
3339 					target_oid  = isp->sess_oid;
3340 					break;
3341 				}
3342 			}
3343 		} else {
3344 			target_oid = llp->ll_tgt_oid;
3345 		}
3346 
3347 
3348 		/*
3349 		 * Look at the LUNs attached to the specified target. If there
3350 		 * is space in the user structure save that information locally.
3351 		 * Always add up the count to the total. By always adding
3352 		 * the count this code can be used if ll_in_cnt == 0 and
3353 		 * the user just wishes to know the appropriate size to
3354 		 * allocate.
3355 		 */
3356 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3357 		for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) {
3358 			if ((llp->ll_all_tgts == B_FALSE) &&
3359 			    (isp->sess_oid != target_oid)) {
3360 				continue;
3361 			}
3362 			rw_enter(&isp->sess_lun_list_rwlock, RW_READER);
3363 			for (ilp = isp->sess_lun_list; ilp;
3364 			    ilp = ilp->lun_next) {
3365 				if ((ilp->lun_state &
3366 				    ISCSI_LUN_STATE_ONLINE) &&
3367 				    !(ilp->lun_state &
3368 				    ISCSI_LUN_STATE_INVALID)) {
3369 					if (llp->ll_out_cnt <
3370 					    llp->ll_in_cnt) {
3371 						iscsi_if_lun_t *lp;
3372 						lp = &llp->ll_luns[
3373 						    llp->ll_out_cnt];
3374 
3375 						lp->l_tgt_oid =
3376 						    isp->sess_oid;
3377 						lp->l_oid = ilp->lun_oid;
3378 						lp->l_num = ilp->lun_num;
3379 					}
3380 				llp->ll_out_cnt++;
3381 				}
3382 			}
3383 			rw_exit(&isp->sess_lun_list_rwlock);
3384 		}
3385 		rw_exit(&ihp->hba_sess_list_rwlock);
3386 
3387 		if (ddi_copyout(llp, (caddr_t)arg, lun_sz, mode)) {
3388 			rtn = EFAULT;
3389 		}
3390 
3391 		kmem_free(llp, lun_sz);
3392 		break;
3393 
3394 	/*
3395 	 * ISCSI_LUN_PROPS_GET --
3396 	 */
3397 	case ISCSI_LUN_PROPS_GET:
3398 		lun = (iscsi_lun_props_t *)kmem_zalloc(sizeof (*lun), KM_SLEEP);
3399 		if (ddi_copyin((caddr_t)arg, lun, sizeof (*lun), mode)) {
3400 			rtn = EFAULT;
3401 			kmem_free(lun, sizeof (*lun));
3402 			break;
3403 		}
3404 
3405 		if (lun->lp_vers != ISCSI_INTERFACE_VERSION) {
3406 			rtn = EINVAL;
3407 			kmem_free(lun, sizeof (*lun));
3408 			break;
3409 		}
3410 
3411 		/*
3412 		 * For the target specified, find the LUN specified and
3413 		 * return its properties
3414 		 */
3415 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3416 		rtn = iscsi_sess_get(lun->lp_tgt_oid, ihp, &isp);
3417 		if (rtn != 0) {
3418 			rw_exit(&ihp->hba_sess_list_rwlock);
3419 			rtn = EFAULT;
3420 			kmem_free(lun, sizeof (*lun));
3421 			break;
3422 		}
3423 		rtn = EINVAL;	/* Set bad rtn, correct only if found */
3424 		rw_enter(&isp->sess_lun_list_rwlock, RW_READER);
3425 		for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) {
3426 			if (ilp->lun_oid == lun->lp_oid) {
3427 				lun->lp_num	= ilp->lun_num;
3428 				lun->lp_status	= LunValid;
3429 				lun->lp_time_online = ilp->lun_time_online;
3430 
3431 				if (ilp->lun_pip != NULL) {
3432 					lun_dip = mdi_pi_get_client(
3433 					    ilp->lun_pip);
3434 				} else {
3435 					lun_dip = ilp->lun_dip;
3436 				}
3437 
3438 				if (lun_dip != NULL &&
3439 				    ((i_ddi_devi_attached(lun_dip)) ||
3440 				    (ddi_get_devstate(lun_dip) ==
3441 				    DDI_DEVSTATE_UP))) {
3442 					(void) ddi_pathname(lun_dip,
3443 					    lun->lp_pathname);
3444 				} else {
3445 					/*
3446 					 * The LUN is not exported to the
3447 					 * OS yet.  It is in the process
3448 					 * of being added.
3449 					 */
3450 					lun->lp_status	= LunDoesNotExist;
3451 				}
3452 				bcopy(ilp->lun_vid, lun->lp_vid,
3453 				    sizeof (lun->lp_vid));
3454 				bcopy(ilp->lun_pid, lun->lp_pid,
3455 				    sizeof (lun->lp_pid));
3456 				rtn = ddi_copyout(lun, (caddr_t)arg,
3457 				    sizeof (*lun), mode);
3458 				if (rtn == -1) {
3459 					rtn = EFAULT;
3460 				}
3461 				break;
3462 			}
3463 		}
3464 		rw_exit(&isp->sess_lun_list_rwlock);
3465 		rw_exit(&ihp->hba_sess_list_rwlock);
3466 
3467 		kmem_free(lun, sizeof (*lun));
3468 		break;
3469 
3470 	/*
3471 	 * ISCSI_CONN_OID_LIST_GET --
3472 	 */
3473 #define	ISCSIIOCOLGC iscsi_ioctl_conn_oid_list_get_copyout
3474 	case ISCSI_CONN_OID_LIST_GET:
3475 		{
3476 			iscsi_conn_list_t	*cl;
3477 
3478 			/* Asuume the worst */
3479 			rtn = EFAULT;
3480 
3481 			/* Copy the input argument into kernel world. */
3482 			cl = iscsi_ioctl_conn_oid_list_get_copyin(
3483 			    (caddr_t)arg,
3484 			    mode);
3485 			if (cl != NULL) {
3486 				if (iscsi_ioctl_conn_oid_list_get(ihp, cl) ==
3487 				    B_TRUE) {
3488 					rtn =
3489 					    ISCSIIOCOLGC(
3490 					    cl, (caddr_t)arg, mode);
3491 				}
3492 			}
3493 			break;
3494 		}
3495 #undef ISCSIIOCOLGC
3496 	/*
3497 	 * ISCSI_CONN_OID_LIST_GET --
3498 	 */
3499 	case ISCSI_CONN_PROPS_GET:
3500 		{
3501 			iscsi_conn_props_t	*cp;
3502 
3503 			/* Asuume the worst */
3504 			rtn = EFAULT;
3505 
3506 			/* Copy the input argument into kernel world. */
3507 			cp = iscsi_ioctl_copyin(
3508 			    (caddr_t)arg,
3509 			    mode,
3510 			    sizeof (iscsi_conn_props_t));
3511 
3512 			if (cp != NULL) {
3513 				/* Get the propereties. */
3514 				if (iscsi_ioctl_conn_props_get(ihp, cp) ==
3515 				    B_TRUE) {
3516 					rtn =
3517 					    iscsi_ioctl_copyout(
3518 					    cp,
3519 					    sizeof (*cp),
3520 					    (caddr_t)arg,
3521 					    mode);
3522 				} else {
3523 					kmem_free(cp, sizeof (*cp));
3524 					cp = NULL;
3525 				}
3526 			}
3527 			break;
3528 		}
3529 
3530 	/*
3531 	 * ISCSI_RADIUS_GET -
3532 	 */
3533 	case ISCSI_RADIUS_GET:
3534 	{
3535 		iscsi_nvfile_status_t	status;
3536 
3537 		radius = (iscsi_radius_props_t *)kmem_zalloc(sizeof (*radius),
3538 		    KM_SLEEP);
3539 		if (ddi_copyin((caddr_t)arg, radius, sizeof (*radius), mode)) {
3540 			kmem_free(radius, sizeof (*radius));
3541 			rtn = EFAULT;
3542 			break;
3543 		} else if (radius->r_vers != ISCSI_INTERFACE_VERSION) {
3544 			kmem_free(radius, sizeof (*radius));
3545 			rtn = EINVAL;
3546 			break;
3547 		}
3548 
3549 		old_oid = radius->r_oid;
3550 
3551 		if (radius->r_oid == ihp->hba_oid) {
3552 			name = ihp->hba_name;
3553 		} else {
3554 			/*
3555 			 * RADIUS configuration should be done on a per
3556 			 * initiator basis.
3557 			 */
3558 			kmem_free(radius, sizeof (*radius));
3559 			rtn = EINVAL;
3560 			break;
3561 		}
3562 
3563 		status = persistent_radius_get(radius);
3564 		if (status == ISCSI_NVFILE_SUCCESS) {
3565 			/*
3566 			 * Restore the value for overridden (and bogus) oid.
3567 			 */
3568 			radius->r_oid = old_oid;
3569 			rtn = ddi_copyout(radius, (caddr_t)arg,
3570 			    sizeof (*radius), mode);
3571 		} else if (status == ISCSI_NVFILE_NAMEVAL_NOT_FOUND) {
3572 			rtn = ENOENT;
3573 		} else {
3574 			rtn = EIO;
3575 		}
3576 		kmem_free(radius, sizeof (*radius));
3577 		break;
3578 	}
3579 
3580 	/*
3581 	 * ISCSI_RADIUS_SET -
3582 	 */
3583 	case ISCSI_RADIUS_SET:
3584 		radius = (iscsi_radius_props_t *)kmem_zalloc(sizeof (*radius),
3585 		    KM_SLEEP);
3586 		if (ddi_copyin((caddr_t)arg, radius, sizeof (*radius), mode)) {
3587 			rtn = EFAULT;
3588 			kmem_free(radius, sizeof (*radius));
3589 			break;
3590 		} else if (radius->r_vers != ISCSI_INTERFACE_VERSION) {
3591 			rtn = EINVAL;
3592 			kmem_free(radius, sizeof (*radius));
3593 			break;
3594 		}
3595 
3596 		if (radius->r_oid == ihp->hba_oid) {
3597 			name = ihp->hba_name;
3598 		} else {
3599 			/*
3600 			 * RADIUS configuration should be done on a per
3601 			 * initiator basis.
3602 			 */
3603 			kmem_free(radius, sizeof (*radius));
3604 			rtn = EINVAL;
3605 			break;
3606 		}
3607 
3608 		if (persistent_radius_set(radius) == B_FALSE) {
3609 			rtn = EIO;
3610 		}
3611 
3612 		kmem_free(radius, sizeof (*radius));
3613 		break;
3614 
3615 	/*
3616 	 *  ISCSI_AUTH_GET -
3617 	 */
3618 	case ISCSI_AUTH_GET:
3619 		auth = (iscsi_auth_props_t *)kmem_zalloc(sizeof (*auth),
3620 		    KM_SLEEP);
3621 		if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) {
3622 			kmem_free(auth, sizeof (*auth));
3623 			rtn = EFAULT;
3624 			break;
3625 		} else if (auth->a_vers != ISCSI_INTERFACE_VERSION) {
3626 			kmem_free(auth, sizeof (*auth));
3627 			rtn = EINVAL;
3628 			break;
3629 		}
3630 
3631 		old_oid = auth->a_oid;
3632 
3633 		if (auth->a_oid == ihp->hba_oid) {
3634 			name = ihp->hba_name;
3635 		} else {
3636 
3637 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3638 			/*
3639 			 * If the oid does represent a session check to see
3640 			 * if it is a target oid.  If so, return the target's
3641 			 * associated session.
3642 			 */
3643 			rtn = iscsi_sess_get(auth->a_oid, ihp, &isp);
3644 			if (rtn != 0) {
3645 				rtn = iscsi_sess_get_by_target(auth->a_oid,
3646 				    ihp, &isp);
3647 			}
3648 			rw_exit(&ihp->hba_sess_list_rwlock);
3649 
3650 			/*
3651 			 * If rtn is zero then we have found an
3652 			 * existing session.  Use the session name to
3653 			 * do param lookup.  If rtn is non-zero then
3654 			 * create a targetparam object and use its name
3655 			 * for param lookup.
3656 			 */
3657 			if (rtn == 0) {
3658 				name = isp->sess_name;
3659 			} else {
3660 				name =
3661 				    iscsi_targetparam_get_name(auth->a_oid);
3662 			}
3663 		}
3664 
3665 		if (name == NULL) {
3666 			rtn = EFAULT;
3667 			break;
3668 		}
3669 
3670 		if (persistent_auth_get((char *)name, auth) == B_TRUE) {
3671 			/*
3672 			 * Restore the value for overridden (and bogus) oid.
3673 			 */
3674 			auth->a_oid = old_oid;
3675 			rtn = ddi_copyout(auth, (caddr_t)arg,
3676 			    sizeof (*auth), mode);
3677 		} else {
3678 			rtn = EIO;
3679 		}
3680 
3681 		kmem_free(auth, sizeof (*auth));
3682 		break;
3683 
3684 	/*
3685 	 *  ISCSI_AUTH_SET -
3686 	 */
3687 	case ISCSI_AUTH_SET:
3688 		auth = (iscsi_auth_props_t *)kmem_zalloc(sizeof (*auth),
3689 		    KM_SLEEP);
3690 		if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) {
3691 			kmem_free(auth, sizeof (*auth));
3692 			rtn = EFAULT;
3693 			break;
3694 		} else if (auth->a_vers != ISCSI_INTERFACE_VERSION) {
3695 			kmem_free(auth, sizeof (*auth));
3696 			rtn = EINVAL;
3697 			break;
3698 		}
3699 
3700 		if (auth->a_oid == ihp->hba_oid) {
3701 			name = ihp->hba_name;
3702 		} else {
3703 			rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3704 			/*
3705 			 * If the oid does represent a session check to see
3706 			 * if it is a target oid.  If so, return the target's
3707 			 * associated session.
3708 			 */
3709 			rtn = iscsi_sess_get(auth->a_oid, ihp, &isp);
3710 			if (rtn != 0) {
3711 				rtn = iscsi_sess_get_by_target(auth->a_oid,
3712 				    ihp, &isp);
3713 			}
3714 			rw_exit(&ihp->hba_sess_list_rwlock);
3715 
3716 			/*
3717 			 * If rtn is zero then we have found an
3718 			 * existing session.  Use the session name to
3719 			 * do param lookup.  If rtn is non-zero then
3720 			 * create a targetparam object and use its name
3721 			 * for param lookup.
3722 			 */
3723 			if (rtn == 0) {
3724 				name = isp->sess_name;
3725 			} else {
3726 				name =
3727 				    iscsi_targetparam_get_name(auth->a_oid);
3728 				rtn = 0;
3729 			}
3730 		}
3731 
3732 		if (name == NULL) {
3733 			rtn = EFAULT;
3734 		} else if (persistent_auth_set((char *)name, auth)
3735 		    == B_FALSE) {
3736 			rtn = EIO;
3737 		}
3738 
3739 		kmem_free(auth, sizeof (*auth));
3740 		break;
3741 
3742 	/*
3743 	 *  ISCSI_AUTH_CLEAR -
3744 	 */
3745 	case ISCSI_AUTH_CLEAR:
3746 		auth = (iscsi_auth_props_t *)kmem_alloc(sizeof (*auth),
3747 		    KM_SLEEP);
3748 		if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) {
3749 			kmem_free(auth, sizeof (*auth));
3750 			rtn = EFAULT;
3751 			break;
3752 		} else if (auth->a_vers != ISCSI_INTERFACE_VERSION) {
3753 			kmem_free(auth, sizeof (*auth));
3754 			rtn = EINVAL;
3755 			break;
3756 		}
3757 
3758 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3759 		/*
3760 		 * If the oid does represent a session check to see
3761 		 * if it is a target oid.  If so, return the target's
3762 		 * associated session.
3763 		 */
3764 		rtn = iscsi_sess_get(auth->a_oid, ihp, &isp);
3765 		if (rtn != 0) {
3766 			rtn = iscsi_sess_get_by_target(auth->a_oid, ihp, &isp);
3767 		}
3768 		rw_exit(&ihp->hba_sess_list_rwlock);
3769 
3770 		/*
3771 		 * If rtn is zero then we have found an
3772 		 * existing session.  Use the session name to
3773 		 * do param lookup.  If rtn is non-zero then
3774 		 * create a targetparam object and use its name
3775 		 * for param lookup.
3776 		 */
3777 		if (rtn == 0) {
3778 			name = isp->sess_name;
3779 		} else {
3780 			name =
3781 			    iscsi_targetparam_get_name(auth->a_oid);
3782 			rtn = 0;
3783 			discovered = B_FALSE;
3784 		}
3785 
3786 		if (name == NULL) {
3787 			rtn = EFAULT;
3788 			break;
3789 		}
3790 
3791 		if (persistent_auth_clear((char *)name) == B_FALSE) {
3792 			rtn = EIO;
3793 		}
3794 
3795 		/*
3796 		 * ISCSI_TARGET_PARAM_CLEAR, ISCSI_CHAP_CLEAR and
3797 		 * ISCSI_AUTH_CLEAR ioctl are called sequentially to remove
3798 		 * target parameters. Here, the target that is not discovered
3799 		 * by initiator should be removed from the iscsi_targets list
3800 		 * residing in the memory.
3801 		 */
3802 		if (discovered == B_FALSE) {
3803 			(void) iscsi_targetparam_remove_target(auth->a_oid);
3804 		}
3805 
3806 		kmem_free(auth, sizeof (*auth));
3807 		break;
3808 
3809 	/*
3810 	 * ISCSI_DB_DUMP -
3811 	 */
3812 	case ISCSI_DB_DUMP:
3813 		persistent_dump_data();
3814 		break;
3815 
3816 	case ISCSI_USCSI:
3817 
3818 #ifdef _MULTI_DATAMODEL
3819 		model = ddi_model_convert_from(mode & FMODELS);
3820 		switch (model) {
3821 		case DDI_MODEL_ILP32:
3822 
3823 			if (ddi_copyin((caddr_t)arg, &iu32_caller,
3824 			    sizeof (iscsi_uscsi32_t), mode)) {
3825 				rtn = EFAULT;
3826 				break;
3827 			}
3828 
3829 			/* perform conversion from 32 -> 64 */
3830 			iu_caller.iu_vers = iu32_caller.iu_vers;
3831 			iu_caller.iu_oid = iu32_caller.iu_oid;
3832 			iu_caller.iu_tpgt = iu32_caller.iu_tpgt;
3833 			iu_caller.iu_len = iu32_caller.iu_len;
3834 			iu_caller.iu_lun = iu32_caller.iu_lun;
3835 			uscsi_cmd32touscsi_cmd((&iu32_caller.iu_ucmd),
3836 			    (&iu_caller.iu_ucmd));
3837 
3838 			break;
3839 		case DDI_MODEL_NONE:
3840 			if (ddi_copyin((caddr_t)arg, &iu_caller,
3841 			    sizeof (iscsi_uscsi_t), mode)) {
3842 				rtn = EFAULT;
3843 				break;
3844 			}
3845 			break;
3846 		default:
3847 			ASSERT(FALSE);
3848 			rtn = EINVAL;
3849 			break;
3850 		}
3851 #endif /* _MULTI_DATAMODEL */
3852 
3853 		/* If failures earlier break */
3854 		if (rtn != 0) {
3855 			break;
3856 		}
3857 
3858 		/* copy from caller to internel cmd */
3859 		bcopy(&iu_caller, &iu, sizeof (iu));
3860 
3861 		if (iu.iu_vers != ISCSI_INTERFACE_VERSION) {
3862 			rtn = EINVAL;
3863 			break;
3864 		}
3865 		/*
3866 		 * Check to see if oid references a target-param oid.  If so,
3867 		 * find the associated  session oid before getting lu list.
3868 		 */
3869 		if (iscsi_targetparam_get_name(iu.iu_oid) != NULL) {
3870 			for (isp = ihp->hba_sess_list; isp; isp =
3871 			    isp->sess_next) {
3872 				if (isp->sess_target_oid == iu.iu_oid) {
3873 					target_oid  = isp->sess_oid;
3874 					break;
3875 				}
3876 			}
3877 		} else {
3878 			target_oid = iu.iu_oid;
3879 		}
3880 
3881 		/* make sure we have a matching session for this command */
3882 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
3883 		rtn = iscsi_sess_get(target_oid, ihp, &isp);
3884 		if (rtn != 0) {
3885 			rtn = iscsi_sess_get_by_target(target_oid, ihp,
3886 			    &isp);
3887 			if (rtn != 0) {
3888 				rw_exit(&ihp->hba_sess_list_rwlock);
3889 				rtn = EFAULT;
3890 				break;
3891 			}
3892 		}
3893 		/*
3894 		 * If a caller buffer is present allocate duplicate
3895 		 * kernel space and copyin caller memory.
3896 		 */
3897 		if (iu.iu_ucmd.uscsi_buflen > 0) {
3898 			iu.iu_ucmd.uscsi_bufaddr = (caddr_t)kmem_alloc(
3899 			    iu.iu_ucmd.uscsi_buflen, KM_SLEEP);
3900 			if (ddi_copyin(iu_caller.iu_ucmd.uscsi_bufaddr,
3901 			    iu.iu_ucmd.uscsi_bufaddr,
3902 			    iu.iu_ucmd.uscsi_buflen, mode)) {
3903 				rw_exit(&ihp->hba_sess_list_rwlock);
3904 				rtn = EFAULT;
3905 				break;
3906 			}
3907 		}
3908 
3909 		/*
3910 		 * If a caller cdb is present allocate duplicate
3911 		 * kernel space and copyin caller memory.
3912 		 */
3913 		if (iu.iu_ucmd.uscsi_cdblen > 0) {
3914 			iu.iu_ucmd.uscsi_cdb = (caddr_t)kmem_alloc(
3915 			    iu_caller.iu_ucmd.uscsi_cdblen, KM_SLEEP);
3916 			if (ddi_copyin(iu_caller.iu_ucmd.uscsi_cdb,
3917 			    iu.iu_ucmd.uscsi_cdb,
3918 			    iu.iu_ucmd.uscsi_cdblen, mode)) {
3919 				if (iu.iu_ucmd.uscsi_buflen > 0) {
3920 					kmem_free(iu.iu_ucmd.uscsi_bufaddr,
3921 					    iu_caller.iu_ucmd.uscsi_buflen);
3922 				}
3923 				rw_exit(&ihp->hba_sess_list_rwlock);
3924 				rtn = EFAULT;
3925 				break;
3926 			}
3927 		}
3928 
3929 		/*
3930 		 * If a caller request sense is present allocate
3931 		 * duplicate kernel space.  No need to copyin.
3932 		 */
3933 		if (iu.iu_ucmd.uscsi_rqlen > 0) {
3934 			iu.iu_ucmd.uscsi_rqbuf = (caddr_t)kmem_alloc(
3935 			    iu.iu_ucmd.uscsi_rqlen, KM_SLEEP);
3936 		}
3937 
3938 		/* issue passthru to io path handler */
3939 		rtn = iscsi_handle_passthru(isp, iu.iu_lun, &iu.iu_ucmd);
3940 		if (rtn != 0) {
3941 			rtn = EFAULT;
3942 		}
3943 
3944 		/*
3945 		 * If the caller had a buf we need to do a copyout
3946 		 * and free the kernel memory
3947 		 */
3948 		if (iu.iu_ucmd.uscsi_buflen > 0) {
3949 			if (ddi_copyout(iu.iu_ucmd.uscsi_bufaddr,
3950 			    iu_caller.iu_ucmd.uscsi_bufaddr,
3951 			    iu.iu_ucmd.uscsi_buflen, mode) != 0) {
3952 				rtn = EFAULT;
3953 			}
3954 			kmem_free(iu.iu_ucmd.uscsi_bufaddr,
3955 			    iu.iu_ucmd.uscsi_buflen);
3956 		}
3957 
3958 		/* We need to free kernel cdb, no need to copyout */
3959 		if (iu.iu_ucmd.uscsi_cdblen > 0) {
3960 			kmem_free(iu.iu_ucmd.uscsi_cdb,
3961 			    iu.iu_ucmd.uscsi_cdblen);
3962 		}
3963 
3964 		/*
3965 		 * If the caller had a request sense we need to
3966 		 * do a copyout and free the kernel memory
3967 		 */
3968 		if (iu.iu_ucmd.uscsi_rqlen > 0) {
3969 			if (ddi_copyout(iu.iu_ucmd.uscsi_rqbuf,
3970 			    iu_caller.iu_ucmd.uscsi_rqbuf,
3971 			    iu.iu_ucmd.uscsi_rqlen - iu.iu_ucmd.uscsi_rqresid,
3972 			    mode) != 0) {
3973 				rtn = EFAULT;
3974 			}
3975 			kmem_free(iu.iu_ucmd.uscsi_rqbuf,
3976 			    iu.iu_ucmd.uscsi_rqlen);
3977 		}
3978 
3979 #ifdef _MULTI_DATAMODEL
3980 		switch (model = ddi_model_convert_from(mode & FMODELS)) {
3981 		case DDI_MODEL_ILP32:
3982 			if (iu.iu_ucmd.uscsi_status != 0) {
3983 				iu32_caller.iu_ucmd.uscsi_status =
3984 				    iu.iu_ucmd.uscsi_status;
3985 				iu32_caller.iu_ucmd.uscsi_rqresid =
3986 				    iu.iu_ucmd.uscsi_rqresid;
3987 			}
3988 			iu32_caller.iu_ucmd.uscsi_resid =
3989 			    iu.iu_ucmd.uscsi_resid;
3990 			if (ddi_copyout((void *)&iu32_caller, (caddr_t)arg,
3991 			    sizeof (iscsi_uscsi32_t), mode) != 0) {
3992 				rtn = EFAULT;
3993 			}
3994 			break;
3995 		case DDI_MODEL_NONE:
3996 			if (iu.iu_ucmd.uscsi_status != 0) {
3997 				iu_caller.iu_ucmd.uscsi_status =
3998 				    iu.iu_ucmd.uscsi_status;
3999 				iu_caller.iu_ucmd.uscsi_rqresid =
4000 				    iu.iu_ucmd.uscsi_rqresid;
4001 			}
4002 			iu_caller.iu_ucmd.uscsi_resid = iu.iu_ucmd.uscsi_resid;
4003 			if (ddi_copyout((void *)&iu_caller, (caddr_t)arg,
4004 			    sizeof (iscsi_uscsi_t), mode) != 0) {
4005 				rtn = EFAULT;
4006 			}
4007 			break;
4008 		default:
4009 			ASSERT(FALSE);
4010 		}
4011 #endif /* _MULTI_DATAMODEL */
4012 		rw_exit(&ihp->hba_sess_list_rwlock);
4013 		break;
4014 
4015 	case ISCSI_SMF_ONLINE:
4016 		if (ddi_copyin((caddr_t)arg, &did, sizeof (int), mode) != 0) {
4017 			rtn = EFAULT;
4018 			break;
4019 		}
4020 		/* just a theoretical case */
4021 		if (ihp->hba_persistent_loaded == B_FALSE) {
4022 			rtn = EFAULT;
4023 			break;
4024 		}
4025 
4026 		/* doesn't need to overwrite the status anymore */
4027 		mutex_enter(&ihp->hba_service_lock);
4028 		if (ihp->hba_service_status_overwrite == B_TRUE) {
4029 			ihp->hba_service_status = ISCSI_SERVICE_DISABLED;
4030 			ihp->hba_service_status_overwrite = B_FALSE;
4031 		}
4032 		mutex_exit(&ihp->hba_service_lock);
4033 
4034 		if (iscsi_enter_service_zone(ihp, ISCSI_SERVICE_ENABLED) ==
4035 		    B_FALSE) {
4036 			break;
4037 		}
4038 
4039 		rval = iscsi_door_bind(did);
4040 		if (rval == B_TRUE) {
4041 			rval = iscsid_start(ihp);
4042 			if (rval == B_FALSE) {
4043 				iscsi_door_unbind();
4044 			}
4045 		}
4046 
4047 		if (rval == B_TRUE) {
4048 			iscsi_exit_service_zone(ihp, ISCSI_SERVICE_ENABLED);
4049 		} else {
4050 			iscsi_exit_service_zone(ihp, ISCSI_SERVICE_DISABLED);
4051 			rtn = EFAULT;
4052 		}
4053 
4054 		break;
4055 
4056 	case ISCSI_SMF_OFFLINE:
4057 		if (iscsi_enter_service_zone(ihp, ISCSI_SERVICE_DISABLED)
4058 		    == B_FALSE) {
4059 			break;
4060 		}
4061 
4062 		rval = iscsid_stop(ihp);
4063 		iscsi_door_unbind();
4064 
4065 		iscsi_exit_service_zone(ihp, ISCSI_SERVICE_DISABLED);
4066 
4067 		if (ddi_copyout((void *)&rval, (caddr_t)arg,
4068 		    sizeof (boolean_t), mode) != 0) {
4069 			rtn = EFAULT;
4070 		}
4071 
4072 		break;
4073 
4074 	case ISCSI_SMF_GET:
4075 		mutex_enter(&ihp->hba_service_lock);
4076 		while (ihp->hba_service_status ==
4077 		    ISCSI_SERVICE_TRANSITION) {
4078 			cv_wait(&ihp->hba_service_cv,
4079 			    &ihp->hba_service_lock);
4080 		}
4081 		if (ddi_copyout((void *)&ihp->hba_service_status,
4082 		    (caddr_t)arg, sizeof (boolean_t), mode) != 0) {
4083 			rtn = EFAULT;
4084 		}
4085 		mutex_exit(&ihp->hba_service_lock);
4086 		break;
4087 
4088 	case ISCSI_DISCOVERY_EVENTS:
4089 		/*
4090 		 * If discovery has not been completed and not in progress,
4091 		 * poke the discovery methods
4092 		 */
4093 		mutex_enter(&ihp->hba_discovery_events_mutex);
4094 		method = ihp->hba_discovery_events;
4095 		if ((method != ISCSI_ALL_DISCOVERY_METHODS) &&
4096 		    (ihp->hba_discovery_in_progress == B_FALSE)) {
4097 			ihp->hba_discovery_in_progress = B_TRUE;
4098 			mutex_exit(&ihp->hba_discovery_events_mutex);
4099 			iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodUnknown);
4100 			mutex_enter(&ihp->hba_discovery_events_mutex);
4101 			ihp->hba_discovery_in_progress = B_FALSE;
4102 			method = ihp->hba_discovery_events;
4103 		}
4104 		mutex_exit(&ihp->hba_discovery_events_mutex);
4105 
4106 		if (ddi_copyout((void *)&method, (caddr_t)arg,
4107 		    sizeof (method), mode) != 0)
4108 			rtn = EFAULT;
4109 		break;
4110 
4111 	/*
4112 	 * ISCSI_SENDTGTS_GET --
4113 	 */
4114 	case ISCSI_SENDTGTS_GET:
4115 		stl_hdr = iscsi_ioctl_copyin((caddr_t)arg, mode,
4116 		    sizeof (*stl_hdr));
4117 		if (stl_hdr == NULL) {
4118 			rtn = EFAULT;
4119 			break;
4120 		}
4121 
4122 		if (stl_hdr->stl_entry.e_vers != ISCSI_INTERFACE_VERSION) {
4123 			rtn = EINVAL;
4124 			kmem_free(stl_hdr, sizeof (*stl_hdr));
4125 			break;
4126 		}
4127 
4128 		/* calculate how much memory user allocated for SendTgts */
4129 		stl_sz = sizeof (*stl_hdr);
4130 		if (stl_hdr->stl_in_cnt > 0) {
4131 			stl_sz += ((stl_hdr->stl_in_cnt - 1) *
4132 			    sizeof (iscsi_sendtgts_entry_t));
4133 		}
4134 
4135 		/* allocate local SendTgts list of the same size */
4136 		istl = kmem_zalloc(stl_sz, KM_SLEEP);
4137 		bcopy(stl_hdr, istl, sizeof (*stl_hdr));
4138 		kmem_free(stl_hdr, sizeof (*stl_hdr));
4139 
4140 		/* lock interface so only one SendTargets operation occurs */
4141 		sema_p(&ihp->hba_sendtgts_semaphore);
4142 
4143 		rtn = iscsi_ioctl_sendtgts_get(ihp, istl);
4144 
4145 		if (rtn == 0) {
4146 			rtn = iscsi_ioctl_copyout(istl, stl_sz,
4147 			    (caddr_t)arg, mode);
4148 		}
4149 
4150 		/* release lock to allow another SendTargets discovery */
4151 		sema_v(&ihp->hba_sendtgts_semaphore);
4152 
4153 		break;
4154 
4155 		/*
4156 		 * ISCSI_ISNS_SERVER_GET --
4157 		 */
4158 	case ISCSI_ISNS_SERVER_GET:
4159 		server_pg_list_hdr = iscsi_ioctl_copyin((caddr_t)arg, mode,
4160 		    sizeof (*server_pg_list_hdr));
4161 		if (server_pg_list_hdr == NULL) {
4162 			rtn = EFAULT;
4163 			break;
4164 		}
4165 
4166 		/* If iSNS discovery mode is not set, return with zero entry */
4167 		method = persistent_disc_meth_get();
4168 		if ((method & iSCSIDiscoveryMethodISNS) == 0) {
4169 			kmem_free(server_pg_list_hdr,
4170 			    sizeof (*server_pg_list_hdr));
4171 			server_pg_list_hdr = NULL;
4172 			rtn = EACCES;
4173 			break;
4174 		}
4175 
4176 		initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP);
4177 		if (persistent_initiator_name_get(initiator_node_name,
4178 		    ISCSI_MAX_NAME_LEN) != B_TRUE) {
4179 			kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
4180 			initiator_node_name = NULL;
4181 			kmem_free(server_pg_list_hdr,
4182 			    sizeof (*server_pg_list_hdr));
4183 			server_pg_list_hdr = NULL;
4184 			rtn = EIO;
4185 			break;
4186 		}
4187 		if (strlen(initiator_node_name) == 0) {
4188 			kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
4189 			initiator_node_name = NULL;
4190 			kmem_free(server_pg_list_hdr,
4191 			    sizeof (*server_pg_list_hdr));
4192 			server_pg_list_hdr = NULL;
4193 			rtn = EIO;
4194 			break;
4195 		}
4196 
4197 		initiator_node_alias = kmem_zalloc(
4198 		    ISCSI_MAX_NAME_LEN, KM_SLEEP);
4199 		if (persistent_alias_name_get(initiator_node_alias,
4200 		    ISCSI_MAX_NAME_LEN) != B_TRUE) {
4201 			initiator_node_alias[0] = '\0';
4202 		}
4203 		rtn = isns_query_one_server(&(server_pg_list_hdr->addr),
4204 		    ihp->hba_isid,
4205 		    (uint8_t *)initiator_node_name,
4206 		    (uint8_t *)initiator_node_alias,
4207 		    ISNS_INITIATOR_NODE_TYPE,
4208 		    &pg_list);
4209 		if (rtn != isns_ok || pg_list == NULL) {
4210 			kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
4211 			initiator_node_name = NULL;
4212 			kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN);
4213 			initiator_node_alias = NULL;
4214 			kmem_free(server_pg_list_hdr,
4215 			    sizeof (*server_pg_list_hdr));
4216 			server_pg_list_hdr = NULL;
4217 			rtn = EIO;
4218 			break;
4219 		}
4220 
4221 		/*
4222 		 * pg_list_sz is the size of the pg_list returned from the
4223 		 *	isns_query_all
4224 		 *
4225 		 * pg_sz_copy_out is the size of the pg_list we are going to
4226 		 *	return back to the caller
4227 		 *
4228 		 * server_pg_list_sz is total amount of data we are returning
4229 		 *	back to the caller
4230 		 */
4231 		pg_list->pg_in_cnt =
4232 		    server_pg_list_hdr->addr_port_list.pg_in_cnt;
4233 		pg_list_sz = sizeof (isns_portal_group_list_t);
4234 		if (pg_list->pg_out_cnt > 0) {
4235 			pg_list_sz += (pg_list->pg_out_cnt - 1) *
4236 			    sizeof (isns_portal_group_t);
4237 		}
4238 		/*
4239 		 * check if caller passed in a buffer with enough space
4240 		 * if there isn't enough space, fill the caller's buffer with
4241 		 * as much information as possible.
4242 		 *
4243 		 * if pg_out_cnt > pg_in_cnt, pg_out_cnt will be returned with
4244 		 * the total number of targets found
4245 		 *
4246 		 * if pg_out_cnt < pg_in_cnt, pg_out_cnt will be the number
4247 		 * of targets returned
4248 		 */
4249 		if (pg_list->pg_in_cnt < pg_list->pg_out_cnt) {
4250 			pg_sz_copy_out = sizeof (isns_portal_group_list_t);
4251 			if (pg_list->pg_in_cnt > 0) {
4252 				pg_sz_copy_out += (pg_list->pg_in_cnt - 1) *
4253 				    sizeof (isns_portal_group_t);
4254 			}
4255 			server_pg_list_sz =
4256 			    sizeof (isns_server_portal_group_list_t);
4257 			if (pg_list->pg_in_cnt > 0) {
4258 				server_pg_list_sz += (pg_list->pg_in_cnt - 1) *
4259 				    sizeof (isns_portal_group_t);
4260 			}
4261 		} else {
4262 			pg_sz_copy_out = pg_list_sz;
4263 			server_pg_list_sz =
4264 			    sizeof (isns_server_portal_group_list_t);
4265 			if (pg_list->pg_out_cnt > 0) {
4266 				server_pg_list_sz += (pg_list->pg_out_cnt - 1) *
4267 				    sizeof (isns_portal_group_t);
4268 			}
4269 		}
4270 
4271 		server_pg_list = (isns_server_portal_group_list_t *)kmem_zalloc(
4272 		    server_pg_list_sz, KM_SLEEP);
4273 
4274 		bcopy(&(server_pg_list_hdr->addr), &(server_pg_list->addr),
4275 		    sizeof (server_pg_list->addr));
4276 		bcopy(pg_list, &server_pg_list->addr_port_list, pg_sz_copy_out);
4277 
4278 		if (ddi_copyout(server_pg_list, (caddr_t)arg, server_pg_list_sz,
4279 		    mode) != 0) {
4280 			rtn = EFAULT;
4281 		}
4282 		DTRACE_PROBE1(iscsi_ioctl_iscsi_isns_server_get_pg_sz,
4283 		    int, pg_list_sz);
4284 		kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN);
4285 		initiator_node_name = NULL;
4286 		kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN);
4287 		initiator_node_alias = NULL;
4288 		kmem_free(pg_list, pg_list_sz);
4289 		pg_list = NULL;
4290 		kmem_free(server_pg_list, server_pg_list_sz);
4291 		server_pg_list = NULL;
4292 		kmem_free(server_pg_list_hdr, sizeof (*server_pg_list_hdr));
4293 		server_pg_list_hdr = NULL;
4294 		break;
4295 
4296 	/*
4297 	 * ISCSI_GET_CONFIG_SESSIONS --
4298 	 */
4299 	case ISCSI_GET_CONFIG_SESSIONS:
4300 		/* FALLTHRU */
4301 
4302 	case ISCSI_SET_CONFIG_SESSIONS:
4303 		size = sizeof (*ics);
4304 		ics = iscsi_ioctl_copyin((caddr_t)arg, mode, size);
4305 		if (ics == NULL) {
4306 			rtn = EFAULT;
4307 			break;
4308 		}
4309 
4310 		/* verify version infomration */
4311 		if (ics->ics_ver != ISCSI_INTERFACE_VERSION) {
4312 			rtn = EINVAL;
4313 			kmem_free(ics, size);
4314 			ics = NULL;
4315 			break;
4316 		}
4317 
4318 		/* Check to see if we need to copy in more memory */
4319 		if (ics->ics_in > 1) {
4320 			/* record correct size */
4321 			size = ISCSI_SESSION_CONFIG_SIZE(ics->ics_in);
4322 			/* free old buffer */
4323 			kmem_free(ics, sizeof (*ics));
4324 
4325 			/* copy in complete buffer size */
4326 			ics = iscsi_ioctl_copyin((caddr_t)arg, mode, size);
4327 			if (ics == NULL) {
4328 				rtn = EFAULT;
4329 				break;
4330 			}
4331 		}
4332 
4333 		/* switch action based on get or set */
4334 		if (cmd == ISCSI_GET_CONFIG_SESSIONS) {
4335 			/* get */
4336 			rtn = iscsi_ioctl_get_config_sess(ihp, ics);
4337 			if (rtn == 0) {
4338 				/* copyout data for gets */
4339 				rtn = iscsi_ioctl_copyout(ics, size,
4340 				    (caddr_t)arg, mode);
4341 			} else {
4342 				kmem_free(ics, size);
4343 				ics = NULL;
4344 			}
4345 		} else {
4346 			/* set */
4347 			rtn = iscsi_ioctl_set_config_sess(ihp, ics);
4348 			if (iscsiboot_prop) {
4349 				if (iscsi_cmp_boot_sess_oid(ihp,
4350 				    ics->ics_oid)) {
4351 					/*
4352 					 * found active session for this object
4353 					 * or this is initiator object
4354 					 * with mpxio enabled
4355 					 */
4356 					if (!iscsi_reconfig_boot_sess(ihp)) {
4357 						kmem_free(ics, size);
4358 						ics = NULL;
4359 						rtn = EINVAL;
4360 						break;
4361 					}
4362 				}
4363 			}
4364 			kmem_free(ics, size);
4365 			ics = NULL;
4366 		}
4367 		break;
4368 
4369 	case ISCSI_IS_ACTIVE:
4370 		/*
4371 		 * dhcpagent calls here to check if there are
4372 		 * active iSCSI sessions
4373 		 */
4374 		instance = 0;
4375 		if (iscsiboot_prop) {
4376 			instance = 1;
4377 		}
4378 		if (!instance) {
4379 			rw_enter(&ihp->hba_sess_list_rwlock,
4380 			    RW_READER);
4381 			for (isp = ihp->hba_sess_list; isp;
4382 			    isp = isp->sess_next) {
4383 				if ((isp->sess_state ==
4384 				    ISCSI_SESS_STATE_LOGGED_IN) &&
4385 				    (isp->sess_lun_list !=
4386 				    NULL)) {
4387 					instance = 1;
4388 					break;
4389 				}
4390 			}
4391 			rw_exit(&ihp->hba_sess_list_rwlock);
4392 		}
4393 		size = sizeof (instance);
4394 		if (ddi_copyout(&instance, (caddr_t)arg, size,
4395 		    mode) != 0) {
4396 			rtn = EFAULT;
4397 		}
4398 		break;
4399 
4400 	case ISCSI_BOOTPROP_GET:
4401 		size = sizeof (*bootProp);
4402 		bootProp = iscsi_ioctl_copyin((caddr_t)arg, mode, size);
4403 		if (bootProp == NULL) {
4404 			rtn = EFAULT;
4405 			break;
4406 		}
4407 		bootProp->hba_mpxio_enabled =
4408 		    iscsi_chk_bootlun_mpxio(ihp);
4409 		if (iscsiboot_prop == NULL) {
4410 			bootProp->iscsiboot = 0;
4411 			rtn = iscsi_ioctl_copyout(bootProp, size,
4412 			    (caddr_t)arg, mode);
4413 			break;
4414 		} else {
4415 			bootProp->iscsiboot = 1;
4416 		}
4417 
4418 		if (iscsiboot_prop->boot_init.ini_name != NULL) {
4419 			(void) strncpy((char *)bootProp->ini_name.n_name,
4420 			    (char *)iscsiboot_prop->boot_init.ini_name,
4421 			    ISCSI_MAX_NAME_LEN);
4422 		}
4423 		if (iscsiboot_prop->boot_init.ini_chap_name != NULL) {
4424 			bootProp->auth.a_auth_method = authMethodCHAP;
4425 			(void) strncpy((char *)bootProp->ini_chap.c_user,
4426 			    (char *)iscsiboot_prop->boot_init.ini_chap_name,
4427 			    ISCSI_MAX_NAME_LEN);
4428 			(void) strncpy((char *)bootProp->ini_chap.c_secret,
4429 			    (char *)iscsiboot_prop->boot_init.ini_chap_sec,
4430 			    ISCSI_CHAP_SECRET_LEN);
4431 			if (iscsiboot_prop->boot_tgt.tgt_chap_name !=
4432 			    NULL) {
4433 				bootProp->auth.a_bi_auth = B_TRUE;
4434 			} else {
4435 				bootProp->auth.a_bi_auth = B_FALSE;
4436 			}
4437 		}
4438 		if (iscsiboot_prop->boot_tgt.tgt_name != NULL) {
4439 			(void) strncpy((char *)bootProp->tgt_name.n_name,
4440 			    (char *)iscsiboot_prop->boot_tgt.tgt_name,
4441 			    ISCSI_MAX_NAME_LEN);
4442 		}
4443 		if (iscsiboot_prop->boot_tgt.tgt_chap_name != NULL) {
4444 			(void) strncpy((char *)bootProp->tgt_chap.c_user,
4445 			    (char *)iscsiboot_prop->boot_tgt.tgt_chap_name,
4446 			    ISCSI_MAX_NAME_LEN);
4447 			(void) strncpy((char *)bootProp->tgt_chap.c_secret,
4448 			    (char *)iscsiboot_prop->boot_tgt.tgt_chap_sec,
4449 			    ISCSI_CHAP_SECRET_LEN);
4450 		}
4451 
4452 		rtn = iscsi_ioctl_copyout(bootProp, size, (caddr_t)arg, mode);
4453 		break;
4454 
4455 	case ISCSI_TARGET_REENUM:
4456 		size = sizeof (iscsi_reen_t);
4457 		reenum = (iscsi_reen_t *)kmem_alloc(size, KM_SLEEP);
4458 
4459 		if (ddi_copyin((caddr_t)arg, reenum, size, mode) != 0) {
4460 			rtn = EFAULT;
4461 			kmem_free(reenum, size);
4462 			break;
4463 		}
4464 		if (reenum->re_ver != ISCSI_INTERFACE_VERSION) {
4465 			rtn = EINVAL;
4466 			kmem_free(reenum, size);
4467 			break;
4468 		}
4469 		rw_enter(&ihp->hba_sess_list_rwlock, RW_READER);
4470 		rtn = iscsi_sess_get(reenum->re_oid, ihp, &isp);
4471 		if (rtn != 0) {
4472 			rtn = iscsi_sess_get_by_target(
4473 			    reenum->re_oid, ihp, &isp);
4474 		}
4475 
4476 		if (rtn != 0) {
4477 			rw_exit(&ihp->hba_sess_list_rwlock);
4478 			kmem_free(reenum, size);
4479 			break;
4480 		}
4481 		kmem_free(reenum, size);
4482 		if (isp->sess_type == ISCSI_SESS_TYPE_NORMAL) {
4483 			rw_enter(&isp->sess_state_rwlock, RW_READER);
4484 			if ((isp->sess_state ==
4485 			    ISCSI_SESS_STATE_LOGGED_IN) &&
4486 			    (iscsi_sess_enum_request(isp, B_TRUE,
4487 			    isp->sess_state_event_count)
4488 			    == ISCSI_SESS_ENUM_SUBMITTED)) {
4489 				(void) iscsi_sess_enum_query(isp);
4490 			}
4491 			rw_exit(&isp->sess_state_rwlock);
4492 		}
4493 		rw_exit(&ihp->hba_sess_list_rwlock);
4494 		break;
4495 
4496 	case ISCSI_TUNABLE_PARAM_SET:
4497 		tpss = (iscsi_tunable_object_t *)kmem_alloc(sizeof (*tpss),
4498 		    KM_SLEEP);
4499 		if (ddi_copyin((caddr_t)arg, tpss, sizeof (*tpss), mode)) {
4500 			rtn = EFAULT;
4501 			kmem_free(tpss, sizeof (*tpss));
4502 			break;
4503 		}
4504 		rtn = iscsi_ioctl_set_tunable_param(ihp, tpss);
4505 		kmem_free(tpss, sizeof (*tpss));
4506 		break;
4507 
4508 	case ISCSI_TUNABLE_PARAM_GET:
4509 		tpsg = (iscsi_tunable_object_t *)kmem_alloc(sizeof (*tpsg),
4510 		    KM_SLEEP);
4511 		if (ddi_copyin((caddr_t)arg, tpsg, sizeof (*tpsg), mode)) {
4512 			rtn = EFAULT;
4513 			kmem_free(tpsg, sizeof (*tpsg));
4514 			break;
4515 		}
4516 		if (tpsg->t_oid == ihp->hba_oid) {
4517 			/* initiator */
4518 			name = ihp->hba_name;
4519 			if (iscsi_get_persisted_tunable_param((uchar_t *)name,
4520 			    tpsg) == 1) {
4521 				/*
4522 				 * no persisted tunable parameters found
4523 				 * for iscsi initiator, use default tunable
4524 				 * params for initiator node.
4525 				 */
4526 				iscsi_get_tunable_default(tpsg);
4527 			}
4528 		} else {
4529 			/* check whether it is a target oid */
4530 			name = iscsi_targetparam_get_name(tpsg->t_oid);
4531 			if (name == NULL) {
4532 				/* invalid node name */
4533 				rtn = EINVAL;
4534 				kmem_free(tpsg, sizeof (*tpsg));
4535 				break;
4536 			}
4537 			if (iscsi_get_persisted_tunable_param((uchar_t *)name,
4538 			    tpsg) == 1) {
4539 				/*
4540 				 * no persisted tunable parameters found for
4541 				 * iscsi target, use initiator's configure.
4542 				 */
4543 				if (iscsi_get_persisted_tunable_param(
4544 				    (uchar_t *)ihp->hba_name, tpsg) == -1) {
4545 					/*
4546 					 * No initiator tunable parameters set
4547 					 * use default value for target
4548 					 */
4549 					iscsi_get_tunable_default(tpsg);
4550 				}
4551 			}
4552 		}
4553 
4554 		if (ddi_copyout(tpsg, (caddr_t)arg,
4555 		    sizeof (iscsi_tunable_object_t), mode) != 0) {
4556 			rtn = EFAULT;
4557 		}
4558 		kmem_free(tpsg, sizeof (*tpsg));
4559 		break;
4560 
4561 	default:
4562 		rtn = ENOTTY;
4563 		cmn_err(CE_NOTE, "unrecognized ioctl 0x%x", cmd);
4564 	} /* end of ioctl type switch/cases */
4565 
4566 	if ((cmd != ISCSI_SMF_ONLINE) && (cmd != ISCSI_SMF_OFFLINE) &&
4567 	    (cmd != ISCSI_SMF_GET)) {
4568 		/* other cmds need to release the service */
4569 		iscsi_client_release_service(ihp);
4570 	}
4571 
4572 	return (rtn);
4573 }
4574 
4575 /*
4576  * +--------------------------------------------------------------------+
4577  * | End of cb_ops routines					     |
4578  * +--------------------------------------------------------------------+
4579  */
4580 
4581 
4582 /*
4583  * +--------------------------------------------------------------------+
4584  * | Common scsi_tran support routines				  |
4585  * +--------------------------------------------------------------------+
4586  */
4587 
4588 /*
4589  * iscsi_i_commoncap -- SCSA host adapter get/set capability routines.
4590  *
4591  * Need to determine if any of these can be determined through the iSCSI
4592  * protocol. For now just return error on most.
4593  */
4594 /* ARGSUSED */
4595 static int
iscsi_i_commoncap(struct scsi_address * ap,char * cap,int val,int tgtonly,int doset)4596 iscsi_i_commoncap(struct scsi_address *ap, char *cap, int val,
4597     int tgtonly, int doset)
4598 {
4599 	int		rtn;
4600 	int		cidx;
4601 	iscsi_lun_t	*ilp;
4602 
4603 	ASSERT((ap)->a_hba_tran->tran_hba_private != NULL);
4604 	ilp	= (iscsi_lun_t *)((ap)->a_hba_tran->tran_tgt_private);
4605 	ASSERT(ilp != NULL);
4606 
4607 	if (cap == (char *)0) {
4608 		return (FALSE);
4609 	}
4610 
4611 	cidx = scsi_hba_lookup_capstr(cap);
4612 	if (cidx == -1) {
4613 		return (cidx);
4614 	}
4615 
4616 	/*
4617 	 * Process setcap request.
4618 	 */
4619 	if (doset) {
4620 		/*
4621 		 * At present, we can only set binary (0/1) values
4622 		 */
4623 		switch (cidx) {
4624 		case SCSI_CAP_LUN_RESET:
4625 			if (val) {
4626 				ilp->lun_cap |= ISCSI_LUN_CAP_RESET;
4627 			} else {
4628 				ilp->lun_cap &= ~ISCSI_LUN_CAP_RESET;
4629 			}
4630 			rtn = TRUE;
4631 			break;
4632 		default:
4633 			/*
4634 			 * None of these are settable via
4635 			 * the capability interface.
4636 			 */
4637 			rtn = FALSE;
4638 			break;
4639 		}
4640 
4641 		/*
4642 		 * Process getcap request.
4643 		 */
4644 	} else {
4645 		switch (cidx) {
4646 		case SCSI_CAP_DMA_MAX:
4647 			/* no DMA, Psuedo value */
4648 			rtn = INT32_MAX;
4649 			break;
4650 		case SCSI_CAP_INITIATOR_ID:
4651 			rtn = 7;
4652 			break;
4653 		case SCSI_CAP_ARQ:
4654 		case SCSI_CAP_RESET_NOTIFICATION:
4655 		case SCSI_CAP_TAGGED_QING:
4656 			rtn = TRUE;
4657 			break;
4658 		case SCSI_CAP_SCSI_VERSION:
4659 			rtn = SCSI_VERSION_3;
4660 			break;
4661 		case SCSI_CAP_INTERCONNECT_TYPE:
4662 			rtn = INTERCONNECT_FABRIC;
4663 			break;
4664 		case SCSI_CAP_LUN_RESET:
4665 			rtn = ((ilp->lun_cap & ISCSI_LUN_CAP_RESET) != 0) ?
4666 			    TRUE : FALSE;
4667 			break;
4668 		case SCSI_CAP_CDB_LEN:
4669 			/*
4670 			 * iSCSI RFC 3720 defines a default 16 byte
4671 			 * CDB as part of the Basic Header Segment
4672 			 * (BHS) (10.2.1) and allows for an Additional
4673 			 * Header Segment (AHS) Length of 255 * 4
4674 			 * (10.2.1.5).  The AHS length can be used
4675 			 * for different purposes two of which are
4676 			 * Extended CDB ADS (10.2.2.3) and Bidirectional
4677 			 * Expected Read-Data Length AHS (10.2.2.4).
4678 			 * The largest header of these consumes is
4679 			 * 32 bytes.  So the total Max CDB Length is
4680 			 * 16 + ((255 * 4 ) - 32) = 1004.
4681 			 */
4682 			rtn = 1004;
4683 			break;
4684 		default:
4685 			rtn = UNDEFINED;
4686 			break;
4687 		}
4688 	}
4689 	return (rtn);
4690 }
4691 
4692 /*
4693  * iscsi_virt_lun_init - attempts to complete a mdi/scsi_vhci binding
4694  *
4695  * This routine is used to associate the tran_tgt_private to our ilp
4696  * structure.  This function is indirectly called from our
4697  * iscsi_lun_create_xxx routines.  These routines must prevent
4698  * the session and lun lists from changing during this call.
4699  */
4700 /* ARGSUSED */
4701 static int
iscsi_virt_lun_init(dev_info_t * hba_dip,dev_info_t * lun_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)4702 iscsi_virt_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
4703     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
4704 {
4705 	iscsi_lun_t	*ilp		= NULL;
4706 	iscsi_lun_t	*ilp_check	= NULL;
4707 	iscsi_sess_t	*isp		= NULL;
4708 	char		*lun_guid	= NULL;
4709 	mdi_pathinfo_t	*pip		= NULL;
4710 	iscsi_hba_t	*ihp    = (iscsi_hba_t *)hba_tran->tran_hba_private;
4711 	char		target_port_name[MAX_NAME_PROP_SIZE];
4712 
4713 	/*
4714 	 * Here's a nice little piece of undocumented stuff.
4715 	 */
4716 	if ((pip = (mdi_pathinfo_t *)sd->sd_private) == NULL) {
4717 		/*
4718 		 * Very bad news if this occurs. Somehow SCSI_vhci has
4719 		 * lost the pathinfo node for this target.
4720 		 */
4721 		return (DDI_NOT_WELL_FORMED);
4722 	}
4723 
4724 	ilp = (iscsi_lun_t *)mdi_pi_get_phci_private(pip);
4725 
4726 	/*
4727 	 * +----------------------------------------------------+
4728 	 * | Looking to find the target device via the property |
4729 	 * | is not required since the driver can easily get    |
4730 	 * | this information from the mdi_phci_get_private()   |
4731 	 * | call above.  This is just a consistency check	|
4732 	 * | which can be removed.				|
4733 	 */
4734 	if (mdi_prop_lookup_string(pip, MDI_GUID, &lun_guid) !=
4735 	    DDI_PROP_SUCCESS) {
4736 		return (DDI_NOT_WELL_FORMED);
4737 	}
4738 
4739 	for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) {
4740 
4741 		/* If this isn't the matching session continue */
4742 		if (ilp->lun_sess != isp) {
4743 			continue;
4744 		}
4745 
4746 		/*
4747 		 * We are already holding the lun list rwlock
4748 		 * for this thread on the callers side of mdi_pi_online
4749 		 * or ndi_devi_online.  Which lead to this functions
4750 		 * call.
4751 		 */
4752 		for (ilp_check = isp->sess_lun_list; ilp_check;
4753 		    ilp_check = ilp_check->lun_next) {
4754 
4755 			/*
4756 			 * If this is the matching LUN and contains
4757 			 * the same LUN GUID then break we found our
4758 			 * match.
4759 			 */
4760 			if ((ilp == ilp_check) &&
4761 			    (strcmp(lun_guid, ilp_check->lun_guid) == 0)) {
4762 				break;
4763 			}
4764 		}
4765 		if (ilp_check != NULL) {
4766 			break;
4767 		}
4768 	}
4769 
4770 	/*
4771 	 * Free resource that's no longer required.
4772 	 */
4773 	if (lun_guid != NULL)
4774 		(void) mdi_prop_free(lun_guid);
4775 
4776 	if (ilp_check == NULL) {
4777 		/*
4778 		 * Failed to find iSCSI LUN in HBA chain based
4779 		 * on the GUID that was stored as a property on
4780 		 * the pathinfo node.
4781 		 */
4782 		return (DDI_NOT_WELL_FORMED);
4783 	}
4784 
4785 	if (ilp != ilp_check) {
4786 		/*
4787 		 * The iSCSI target that we found on the HBA link is
4788 		 * different than the iSCSI target that was stored as
4789 		 * private data on the pathinfo node.
4790 		 */
4791 		return (DDI_NOT_WELL_FORMED);
4792 	}
4793 	/*
4794 	 * | End of consistency check				|
4795 	 * +----------------------------------------------------+
4796 	 */
4797 
4798 	hba_tran->tran_tgt_private = ilp;
4799 
4800 	target_port_name[0] = '\0';
4801 	if (ilp->lun_sess->sess_tpgt_conf == ISCSI_DEFAULT_TPGT) {
4802 		(void) snprintf(target_port_name, MAX_NAME_PROP_SIZE,
4803 		    "%02x%02x%02x%02x%02x%02x,%s",
4804 		    ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1],
4805 		    ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3],
4806 		    ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5],
4807 		    ilp->lun_sess->sess_name);
4808 	} else {
4809 		(void) snprintf(target_port_name, MAX_NAME_PROP_SIZE,
4810 		    "%02x%02x%02x%02x%02x%02x,%s,%d",
4811 		    ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1],
4812 		    ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3],
4813 		    ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5],
4814 		    ilp->lun_sess->sess_name, ilp->lun_sess->sess_tpgt_conf);
4815 	}
4816 
4817 	if (mdi_prop_update_string(pip,
4818 	    SCSI_ADDR_PROP_TARGET_PORT, target_port_name) != DDI_PROP_SUCCESS) {
4819 		cmn_err(CE_WARN, "iscsi_virt_lun_init: Creating '"
4820 		    SCSI_ADDR_PROP_TARGET_PORT "' property on Path(%p) "
4821 		    "for Target(%s), Lun(%d) Failed",
4822 		    (void *)pip, ilp->lun_sess->sess_name, ilp->lun_num);
4823 	}
4824 
4825 	return (DDI_SUCCESS);
4826 }
4827 
4828 /*
4829  * iscsi_phys_lun_init - attempts to complete a ndi binding
4830  *
4831  * This routine is used to associate the tran_tgt_private to our
4832  * ilp structure.  This function is indirectly called from our
4833  * iscsi_lun_create_xxx routines.  These routines must prevent
4834  * the session and lun lists from changing during this call.
4835  */
4836 static int
iscsi_phys_lun_init(dev_info_t * hba_dip,dev_info_t * lun_dip,scsi_hba_tran_t * hba_tran,struct scsi_device * sd)4837 iscsi_phys_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip,
4838     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
4839 {
4840 	int		rtn	= DDI_SUCCESS;
4841 	iscsi_hba_t	*ihp	= NULL;
4842 	iscsi_sess_t	*isp	= NULL;
4843 	iscsi_lun_t	*ilp	= NULL;
4844 	char		target_port_name[MAX_NAME_PROP_SIZE];
4845 	int		*words = NULL;
4846 	uint_t		nwords = 0;
4847 
4848 	ASSERT(hba_dip);
4849 	ASSERT(lun_dip);
4850 	ASSERT(hba_tran);
4851 	ASSERT(sd);
4852 	ihp = (iscsi_hba_t *)hba_tran->tran_hba_private;
4853 	ASSERT(ihp);
4854 
4855 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, lun_dip,
4856 	    DDI_PROP_DONTPASS, LUN_PROP, &words, &nwords) != DDI_PROP_SUCCESS) {
4857 		cmn_err(CE_WARN, "iscsi_phys_lun_init: Returning DDI_FAILURE:"
4858 		    "lun for %s (instance %d)", ddi_get_name(lun_dip),
4859 		    ddi_get_instance(lun_dip));
4860 		return (DDI_FAILURE);
4861 	}
4862 
4863 	if (nwords == 0) {
4864 		ddi_prop_free(words);
4865 		return (DDI_FAILURE);
4866 	}
4867 
4868 	ASSERT(words != NULL);
4869 
4870 	/* See if we already created this session */
4871 
4872 	/* Walk the HBA's session list */
4873 	for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) {
4874 		/* compare target name as the unique identifier */
4875 		if (sd->sd_address.a_target == isp->sess_oid) {
4876 			/* found match */
4877 			break;
4878 		}
4879 	}
4880 
4881 	/* If we found matching session continue searching for tgt */
4882 	if (isp != NULL) {
4883 		/*
4884 		 * Search for the matching iscsi lun structure.  We don't
4885 		 * need to hold the READER for the lun list at this point.
4886 		 * because the tran_get_name is being called from the online
4887 		 * function which is already holding a reader on the lun
4888 		 * list.
4889 		 */
4890 		for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) {
4891 			if (*words == ilp->lun_num) {
4892 				/* found match */
4893 				break;
4894 			}
4895 		}
4896 
4897 		if (ilp != NULL) {
4898 			/*
4899 			 * tgt found path it to the tran_lun_private
4900 			 * this is used later for fast access on
4901 			 * init_pkt and start
4902 			 */
4903 			hba_tran->tran_tgt_private = ilp;
4904 		} else {
4905 			/* tgt not found */
4906 			ddi_prop_free(words);
4907 			return (DDI_FAILURE);
4908 		}
4909 	} else {
4910 		/* sess not found */
4911 		ddi_prop_free(words);
4912 		return (DDI_FAILURE);
4913 	}
4914 	ddi_prop_free(words);
4915 
4916 	target_port_name[0] = '\0';
4917 	if (ilp->lun_sess->sess_tpgt_conf == ISCSI_DEFAULT_TPGT) {
4918 		(void) snprintf(target_port_name, MAX_NAME_PROP_SIZE,
4919 		    "%02x%02x%02x%02x%02x%02x,%s",
4920 		    ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1],
4921 		    ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3],
4922 		    ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5],
4923 		    ilp->lun_sess->sess_name);
4924 	} else {
4925 		(void) snprintf(target_port_name, MAX_NAME_PROP_SIZE,
4926 		    "%02x%02x%02x%02x%02x%02x,%s,%d",
4927 		    ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1],
4928 		    ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3],
4929 		    ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5],
4930 		    ilp->lun_sess->sess_name, ilp->lun_sess->sess_tpgt_conf);
4931 	}
4932 
4933 	if (ddi_prop_update_string(DDI_DEV_T_NONE, lun_dip,
4934 	    SCSI_ADDR_PROP_TARGET_PORT, target_port_name) != DDI_PROP_SUCCESS) {
4935 		cmn_err(CE_WARN, "iscsi_phys_lun_init: Creating '"
4936 		    SCSI_ADDR_PROP_TARGET_PORT "' property on Target(%s), "
4937 		    "Lun(%d) Failed", ilp->lun_sess->sess_name, ilp->lun_num);
4938 	}
4939 
4940 	return (rtn);
4941 }
4942 
4943 /*
4944  * +--------------------------------------------------------------------+
4945  * | End of scsi_tran support routines					|
4946  * +--------------------------------------------------------------------+
4947  */
4948 
4949 /*
4950  * +--------------------------------------------------------------------+
4951  * | Begin of struct utility routines					|
4952  * +--------------------------------------------------------------------+
4953  */
4954 
4955 
4956 /*
4957  * iscsi_set_default_login_params - This function sets the
4958  * driver default login params.  This is using during the
4959  * creation of our iSCSI HBA structure initialization by
4960  * could be used at other times to reset back to the defaults.
4961  */
4962 void
iscsi_set_default_login_params(iscsi_login_params_t * params)4963 iscsi_set_default_login_params(iscsi_login_params_t *params)
4964 {
4965 	params->immediate_data		= ISCSI_DEFAULT_IMMEDIATE_DATA;
4966 	params->initial_r2t		= ISCSI_DEFAULT_INITIALR2T;
4967 	params->first_burst_length	= ISCSI_DEFAULT_FIRST_BURST_LENGTH;
4968 	params->max_burst_length	= ISCSI_DEFAULT_MAX_BURST_LENGTH;
4969 	params->data_pdu_in_order	= ISCSI_DEFAULT_DATA_PDU_IN_ORDER;
4970 	params->data_sequence_in_order	= ISCSI_DEFAULT_DATA_SEQUENCE_IN_ORDER;
4971 	params->default_time_to_wait	= ISCSI_DEFAULT_TIME_TO_WAIT;
4972 	params->default_time_to_retain	= ISCSI_DEFAULT_TIME_TO_RETAIN;
4973 	params->header_digest		= ISCSI_DEFAULT_HEADER_DIGEST;
4974 	params->data_digest		= ISCSI_DEFAULT_DATA_DIGEST;
4975 	params->max_recv_data_seg_len	= ISCSI_DEFAULT_MAX_RECV_SEG_LEN;
4976 	params->max_xmit_data_seg_len	= ISCSI_DEFAULT_MAX_XMIT_SEG_LEN;
4977 	params->max_connections		= ISCSI_DEFAULT_MAX_CONNECTIONS;
4978 	params->max_outstanding_r2t	= ISCSI_DEFAULT_MAX_OUT_R2T;
4979 	params->error_recovery_level	= ISCSI_DEFAULT_ERROR_RECOVERY_LEVEL;
4980 	params->ifmarker		= ISCSI_DEFAULT_IFMARKER;
4981 	params->ofmarker		= ISCSI_DEFAULT_OFMARKER;
4982 }
4983 
4984 /* Helper function to sets the driver default tunable parameters */
4985 static void
iscsi_set_default_tunable_params(iscsi_tunable_params_t * params)4986 iscsi_set_default_tunable_params(iscsi_tunable_params_t *params)
4987 {
4988 	params->recv_login_rsp_timeout = ISCSI_DEFAULT_RX_TIMEOUT_VALUE;
4989 	params->conn_login_max = ISCSI_DEFAULT_CONN_DEFAULT_LOGIN_MAX;
4990 	params->polling_login_delay = ISCSI_DEFAULT_LOGIN_POLLING_DELAY;
4991 }
4992 
4993 /*
4994  * +--------------------------------------------------------------------+
4995  * | End of struct utility routines				     |
4996  * +--------------------------------------------------------------------+
4997  */
4998 
4999 /*
5000  * +--------------------------------------------------------------------+
5001  * | Begin of ioctl utility routines				    |
5002  * +--------------------------------------------------------------------+
5003  */
5004 
5005 /*
5006  * iscsi_get_param - This function is a helper to ISCSI_GET_PARAM
5007  * IOCTL
5008  */
5009 int
iscsi_get_param(iscsi_login_params_t * params,boolean_t valid_flag,iscsi_param_get_t * ipgp)5010 iscsi_get_param(iscsi_login_params_t *params, boolean_t valid_flag,
5011     iscsi_param_get_t *ipgp)
5012 {
5013 	int rtn = 0;
5014 
5015 	/* ---- Default to settable, possibly changed later ---- */
5016 	ipgp->g_value.v_valid    = valid_flag;
5017 	ipgp->g_value.v_settable = B_TRUE;
5018 
5019 	switch (ipgp->g_param) {
5020 	/*
5021 	 * Boolean parameters
5022 	 */
5023 	case ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER:
5024 		ipgp->g_value.v_bool.b_current =
5025 		    params->data_sequence_in_order;
5026 		ipgp->g_value.v_bool.b_default =
5027 		    ISCSI_DEFAULT_DATA_SEQUENCE_IN_ORDER;
5028 		break;
5029 	case ISCSI_LOGIN_PARAM_IMMEDIATE_DATA:
5030 		ipgp->g_value.v_bool.b_current =
5031 		    params->immediate_data;
5032 		ipgp->g_value.v_bool.b_default =
5033 		    ISCSI_DEFAULT_IMMEDIATE_DATA;
5034 		break;
5035 	case ISCSI_LOGIN_PARAM_INITIAL_R2T:
5036 		ipgp->g_value.v_bool.b_current =
5037 		    params->initial_r2t;
5038 		ipgp->g_value.v_bool.b_default =
5039 		    ISCSI_DEFAULT_IMMEDIATE_DATA;
5040 		break;
5041 	case ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER:
5042 		ipgp->g_value.v_bool.b_current =
5043 		    params->data_pdu_in_order;
5044 		ipgp->g_value.v_bool.b_default =
5045 		    ISCSI_DEFAULT_DATA_PDU_IN_ORDER;
5046 		break;
5047 
5048 	/*
5049 	 * Integer parameters
5050 	 */
5051 	case ISCSI_LOGIN_PARAM_HEADER_DIGEST:
5052 		ipgp->g_value.v_integer.i_current = params->header_digest;
5053 		ipgp->g_value.v_integer.i_default = ISCSI_DEFAULT_HEADER_DIGEST;
5054 		ipgp->g_value.v_integer.i_min = 0;
5055 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_HEADER_DIGEST;
5056 		ipgp->g_value.v_integer.i_incr = 1;
5057 		break;
5058 	case ISCSI_LOGIN_PARAM_DATA_DIGEST:
5059 		ipgp->g_value.v_integer.i_current = params->data_digest;
5060 		ipgp->g_value.v_integer.i_default = ISCSI_DEFAULT_DATA_DIGEST;
5061 		ipgp->g_value.v_integer.i_min = 0;
5062 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_DATA_DIGEST;
5063 		ipgp->g_value.v_integer.i_incr = 1;
5064 		break;
5065 	case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN:
5066 		ipgp->g_value.v_integer.i_current =
5067 		    params->default_time_to_retain;
5068 		ipgp->g_value.v_integer.i_default =
5069 		    ISCSI_DEFAULT_TIME_TO_RETAIN;
5070 		ipgp->g_value.v_integer.i_min = 0;
5071 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_TIME2RETAIN;
5072 		ipgp->g_value.v_integer.i_incr = 1;
5073 		break;
5074 	case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT:
5075 		ipgp->g_value.v_integer.i_current =
5076 		    params->default_time_to_wait;
5077 		ipgp->g_value.v_integer.i_default =
5078 		    ISCSI_DEFAULT_TIME_TO_WAIT;
5079 		ipgp->g_value.v_integer.i_min = 0;
5080 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_TIME2WAIT;
5081 		ipgp->g_value.v_integer.i_incr = 1;
5082 		break;
5083 	case ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL:
5084 		ipgp->g_value.v_integer.i_current =
5085 		    params->error_recovery_level;
5086 		ipgp->g_value.v_integer.i_default =
5087 		    ISCSI_DEFAULT_ERROR_RECOVERY_LEVEL;
5088 		ipgp->g_value.v_integer.i_min = 0;
5089 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_ERROR_RECOVERY_LEVEL;
5090 		ipgp->g_value.v_integer.i_incr = 1;
5091 		ipgp->g_value.v_settable = B_FALSE;
5092 		break;
5093 	case ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH:
5094 		ipgp->g_value.v_integer.i_current =
5095 		    params->first_burst_length;
5096 		ipgp->g_value.v_integer.i_default =
5097 		    ISCSI_DEFAULT_FIRST_BURST_LENGTH;
5098 		ipgp->g_value.v_integer.i_min = 512;
5099 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_FIRST_BURST_LENGTH;
5100 		ipgp->g_value.v_integer.i_incr = 1;
5101 		break;
5102 	case ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH:
5103 		ipgp->g_value.v_integer.i_current =
5104 		    params->max_burst_length;
5105 		ipgp->g_value.v_integer.i_default =
5106 		    ISCSI_DEFAULT_MAX_BURST_LENGTH;
5107 		ipgp->g_value.v_integer.i_min = 512;
5108 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_BURST_LENGTH;
5109 		ipgp->g_value.v_integer.i_incr = 1;
5110 		break;
5111 	case ISCSI_LOGIN_PARAM_MAX_CONNECTIONS:
5112 		ipgp->g_value.v_integer.i_current =
5113 		    params->max_connections;
5114 		ipgp->g_value.v_settable = B_FALSE;
5115 		ipgp->g_value.v_integer.i_default =
5116 		    ISCSI_DEFAULT_MAX_CONNECTIONS;
5117 		ipgp->g_value.v_integer.i_min = 1;
5118 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_CONNECTIONS;
5119 		ipgp->g_value.v_integer.i_incr = 1;
5120 		break;
5121 	case ISCSI_LOGIN_PARAM_OUTSTANDING_R2T:
5122 		ipgp->g_value.v_integer.i_current =
5123 		    params->max_outstanding_r2t;
5124 		ipgp->g_value.v_settable = B_FALSE;
5125 		ipgp->g_value.v_integer.i_default =
5126 		    ISCSI_DEFAULT_MAX_OUT_R2T;
5127 		ipgp->g_value.v_integer.i_min = 1;
5128 		ipgp->g_value.v_integer.i_max = ISCSI_MAX_OUTSTANDING_R2T;
5129 		ipgp->g_value.v_integer.i_incr = 1;
5130 		break;
5131 	case ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH:
5132 		ipgp->g_value.v_integer.i_current =
5133 		    params->max_recv_data_seg_len;
5134 		ipgp->g_value.v_integer.i_default =
5135 		    ISCSI_DEFAULT_MAX_RECV_SEG_LEN;
5136 		ipgp->g_value.v_integer.i_min = 512;
5137 		ipgp->g_value.v_integer.i_max =
5138 		    ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH;
5139 		ipgp->g_value.v_integer.i_incr = 1;
5140 		break;
5141 	default:
5142 		rtn = EINVAL;
5143 	}
5144 
5145 	return (rtn);
5146 }
5147 
5148 /*
5149  * +--------------------------------------------------------------------+
5150  * | End of ioctl utility routines                                      |
5151  * +--------------------------------------------------------------------+
5152  */
5153 
5154 /*
5155  * iscsi_get_name_from_iqn - Translates a normal iqn/eui into a
5156  * IEEE safe address.  IEEE addresses have a number of characters
5157  * set aside as reserved.
5158  */
5159 static void
iscsi_get_name_from_iqn(char * name,int name_max_len)5160 iscsi_get_name_from_iqn(char *name, int name_max_len)
5161 {
5162 	char	*tmp		= NULL;
5163 	char	*oldch		= NULL;
5164 	char	*newch		= NULL;
5165 
5166 	tmp = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP);
5167 
5168 	for (oldch = &name[0], newch = &tmp[0]; *oldch != '\0';
5169 	    oldch++, newch++) {
5170 		switch (*oldch) {
5171 		case ':':
5172 			*newch++ = '%';
5173 			*newch++ = '3';
5174 			*newch = 'A';
5175 			break;
5176 		case ' ':
5177 			*newch++ = '%';
5178 			*newch++ = '2';
5179 			*newch = '0';
5180 			break;
5181 		case '@':
5182 			*newch++ = '%';
5183 			*newch++ = '4';
5184 			*newch = '0';
5185 			break;
5186 		case '/':
5187 			*newch++ = '%';
5188 			*newch++ = '2';
5189 			*newch = 'F';
5190 			break;
5191 		default:
5192 			*newch = *oldch;
5193 		}
5194 	}
5195 	(void) strncpy(name, tmp, name_max_len);
5196 	kmem_free(tmp, MAX_GET_NAME_SIZE);
5197 }
5198 
5199 /*
5200  * iscsi_get_name_to_iqn - Converts IEEE safe address back
5201  * into a iscsi iqn/eui.
5202  */
5203 static void
iscsi_get_name_to_iqn(char * name,int name_max_len)5204 iscsi_get_name_to_iqn(char *name, int name_max_len)
5205 {
5206 	char	*tmp		= NULL;
5207 	char	*oldch		= NULL;
5208 	char	*newch		= NULL;
5209 
5210 	tmp = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP);
5211 
5212 	for (oldch = &name[0], newch = &tmp[0]; *oldch != '\0';
5213 	    oldch++, newch++) {
5214 		if (*oldch == '%') {
5215 			switch (*(oldch+1)) {
5216 			case '2':
5217 				if (*(oldch+2) == '0') {
5218 					*newch = ' ';
5219 					oldch += 2;
5220 				} else if (*(oldch+2) == 'F') {
5221 					*newch = '/';
5222 					oldch += 2;
5223 				} else {
5224 					*newch = *oldch;
5225 				}
5226 				break;
5227 			case '3':
5228 				if (*(oldch+2) == 'A') {
5229 					*newch = ':';
5230 					oldch += 2;
5231 				} else {
5232 					*newch = *oldch;
5233 				}
5234 				break;
5235 			case '4':
5236 				if (*(oldch+2) == '0') {
5237 					*newch = '@';
5238 					oldch += 2;
5239 				} else {
5240 					*newch = *oldch;
5241 				}
5242 				break;
5243 			default:
5244 				*newch = *oldch;
5245 			}
5246 		} else {
5247 			*newch = *oldch;
5248 		}
5249 	}
5250 	(void) strncpy(name, tmp, name_max_len);
5251 	kmem_free(tmp, MAX_GET_NAME_SIZE);
5252 }
5253 
5254 /*
5255  * iscsi_get_persisted_param * - a helper to ISCSI_GET_PARAM ioctl
5256  *
5257  * On return 0 means persisted parameter found
5258  */
5259 int
iscsi_get_persisted_param(uchar_t * name,iscsi_param_get_t * ipgp,iscsi_login_params_t * params)5260 iscsi_get_persisted_param(uchar_t *name, iscsi_param_get_t *ipgp,
5261     iscsi_login_params_t *params)
5262 {
5263 	int rtn = 1;
5264 	persistent_param_t *pparam;
5265 
5266 	if (name == NULL || strlen((char *)name) == 0) {
5267 		return (rtn);
5268 	}
5269 
5270 	pparam = (persistent_param_t *)kmem_zalloc(sizeof (*pparam), KM_SLEEP);
5271 
5272 	if (persistent_param_get((char *)name, pparam) == B_TRUE) {
5273 		if (pparam->p_bitmap & (1 << ipgp->g_param)) {
5274 			/* Found configured parameter. */
5275 			bcopy(&pparam->p_params, params, sizeof (*params));
5276 			rtn = 0;
5277 		}
5278 	}
5279 
5280 	kmem_free(pparam, sizeof (*pparam));
5281 
5282 	return (rtn);
5283 }
5284 
5285 /*
5286  * iscsi_override_target_default - helper function set the target's default
5287  * login parameter if there is a configured initiator parameter.
5288  *
5289  */
5290 static void
iscsi_override_target_default(iscsi_hba_t * ihp,iscsi_param_get_t * ipg)5291 iscsi_override_target_default(iscsi_hba_t *ihp, iscsi_param_get_t *ipg)
5292 {
5293 	persistent_param_t *pp;
5294 	iscsi_login_params_t *params;
5295 
5296 	pp = (persistent_param_t *)kmem_zalloc(sizeof (*pp), KM_SLEEP);
5297 	if (persistent_param_get((char *)ihp->hba_name, pp) == B_TRUE) {
5298 		if (pp->p_bitmap & (1 << ipg->g_param)) {
5299 			params = &pp->p_params;
5300 			switch (ipg->g_param) {
5301 			case ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER:
5302 				ipg->g_value.v_bool.b_default =
5303 				    params->data_sequence_in_order;
5304 				break;
5305 			case ISCSI_LOGIN_PARAM_IMMEDIATE_DATA:
5306 				ipg->g_value.v_bool.b_default =
5307 				    params->immediate_data;
5308 				break;
5309 			case ISCSI_LOGIN_PARAM_INITIAL_R2T:
5310 				ipg->g_value.v_bool.b_default =
5311 				    params->initial_r2t;
5312 				break;
5313 			case ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER:
5314 				ipg->g_value.v_bool.b_default =
5315 				    params->data_pdu_in_order;
5316 				break;
5317 			case ISCSI_LOGIN_PARAM_HEADER_DIGEST:
5318 				ipg->g_value.v_integer.i_default =
5319 				    params->header_digest;
5320 				break;
5321 			case ISCSI_LOGIN_PARAM_DATA_DIGEST:
5322 				ipg->g_value.v_integer.i_default =
5323 				    params->data_digest;
5324 				break;
5325 			case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN:
5326 				ipg->g_value.v_integer.i_default =
5327 				    params->default_time_to_retain;
5328 				break;
5329 			case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT:
5330 				ipg->g_value.v_integer.i_default =
5331 				    params->default_time_to_wait;
5332 				break;
5333 			case ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL:
5334 				ipg->g_value.v_integer.i_default =
5335 				    params->error_recovery_level;
5336 				break;
5337 			case ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH:
5338 				ipg->g_value.v_integer.i_default =
5339 				    params->first_burst_length;
5340 				break;
5341 			case ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH:
5342 				ipg->g_value.v_integer.i_default =
5343 				    params->max_burst_length;
5344 				break;
5345 			case ISCSI_LOGIN_PARAM_MAX_CONNECTIONS:
5346 				ipg->g_value.v_integer.i_default =
5347 				    params->max_connections;
5348 				break;
5349 			case ISCSI_LOGIN_PARAM_OUTSTANDING_R2T:
5350 				ipg->g_value.v_integer.i_default =
5351 				    params->max_outstanding_r2t;
5352 				break;
5353 			case ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH:
5354 				ipg->g_value.v_integer.i_default =
5355 				    params->max_xmit_data_seg_len;
5356 				break;
5357 			default:
5358 				break;
5359 			}
5360 		}
5361 	}
5362 	kmem_free(pp, sizeof (*pp));
5363 }
5364 
5365 static boolean_t
iscsi_cmp_boot_sess_oid(iscsi_hba_t * ihp,uint32_t oid)5366 iscsi_cmp_boot_sess_oid(iscsi_hba_t *ihp, uint32_t oid)
5367 {
5368 	iscsi_sess_t *isp = NULL;
5369 
5370 	if (iscsi_chk_bootlun_mpxio(ihp)) {
5371 		for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) {
5372 			if ((isp->sess_oid == oid) && isp->sess_boot) {
5373 				/* oid is session object */
5374 				break;
5375 			}
5376 			if ((isp->sess_target_oid == oid) && isp->sess_boot) {
5377 				/*
5378 				 * oid is target object while
5379 				 * this session is boot session
5380 				 */
5381 				break;
5382 			}
5383 		}
5384 		if (oid == ihp->hba_oid) {
5385 			/* oid is initiator object id */
5386 			return (B_TRUE);
5387 		} else if ((isp != NULL) && (isp->sess_boot)) {
5388 			/* oid is boot session object id */
5389 			return (B_TRUE);
5390 		}
5391 	}
5392 	return (B_FALSE);
5393 }
5394 
5395 /*
5396  * iscsi_client_request_service - request the iSCSI service
5397  *     returns true if the service is enabled and increases the count
5398  *     returns false if the service is disabled
5399  *     blocks until the service status is either enabled or disabled
5400  */
5401 boolean_t
iscsi_client_request_service(iscsi_hba_t * ihp)5402 iscsi_client_request_service(iscsi_hba_t *ihp)
5403 {
5404 	boolean_t	rval = B_TRUE;
5405 
5406 	mutex_enter(&ihp->hba_service_lock);
5407 	while ((ihp->hba_service_status == ISCSI_SERVICE_TRANSITION) ||
5408 	    (ihp->hba_service_client_count == UINT_MAX)) {
5409 		cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock);
5410 	}
5411 	if (ihp->hba_service_status == ISCSI_SERVICE_ENABLED) {
5412 		ihp->hba_service_client_count++;
5413 	} else {
5414 		rval = B_FALSE;
5415 	}
5416 	mutex_exit(&ihp->hba_service_lock);
5417 
5418 	return (rval);
5419 }
5420 
5421 /*
5422  * iscsi_client_release_service - decrease the count and wake up
5423  *     blocking threads if the count reaches zero
5424  */
5425 void
iscsi_client_release_service(iscsi_hba_t * ihp)5426 iscsi_client_release_service(iscsi_hba_t *ihp)
5427 {
5428 	mutex_enter(&ihp->hba_service_lock);
5429 	ASSERT(ihp->hba_service_client_count > 0);
5430 	ihp->hba_service_client_count--;
5431 	if (ihp->hba_service_client_count == 0) {
5432 		cv_broadcast(&ihp->hba_service_cv);
5433 	}
5434 	mutex_exit(&ihp->hba_service_lock);
5435 }
5436 
5437 /*
5438  * iscsi_enter_service_zone - enter the service zone, should be called
5439  * before doing any modifications to the service status
5440  * return TRUE if the zone is entered
5441  *	  FALSE if no need to enter the zone
5442  */
5443 static boolean_t
iscsi_enter_service_zone(iscsi_hba_t * ihp,uint32_t status)5444 iscsi_enter_service_zone(iscsi_hba_t *ihp, uint32_t status)
5445 {
5446 	if ((status != ISCSI_SERVICE_ENABLED) &&
5447 	    (status != ISCSI_SERVICE_DISABLED)) {
5448 		return (B_FALSE);
5449 	}
5450 
5451 	mutex_enter(&ihp->hba_service_lock);
5452 	while (ihp->hba_service_status == ISCSI_SERVICE_TRANSITION) {
5453 		cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock);
5454 	}
5455 	if (ihp->hba_service_status == status) {
5456 		mutex_exit(&ihp->hba_service_lock);
5457 		return (B_FALSE);
5458 	}
5459 	ihp->hba_service_status = ISCSI_SERVICE_TRANSITION;
5460 	while (ihp->hba_service_client_count > 0) {
5461 		cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock);
5462 	}
5463 	mutex_exit(&ihp->hba_service_lock);
5464 	return (B_TRUE);
5465 }
5466 
5467 /*
5468  * iscsi_exit_service_zone - exits the service zone and wakes up waiters
5469  */
5470 static void
iscsi_exit_service_zone(iscsi_hba_t * ihp,uint32_t status)5471 iscsi_exit_service_zone(iscsi_hba_t *ihp, uint32_t status)
5472 {
5473 	if ((status != ISCSI_SERVICE_ENABLED) &&
5474 	    (status != ISCSI_SERVICE_DISABLED)) {
5475 		return;
5476 	}
5477 
5478 	mutex_enter(&ihp->hba_service_lock);
5479 	ASSERT(ihp->hba_service_status == ISCSI_SERVICE_TRANSITION);
5480 	ihp->hba_service_status = status;
5481 	cv_broadcast(&ihp->hba_service_cv);
5482 	mutex_exit(&ihp->hba_service_lock);
5483 }
5484 
5485 static void
iscsi_check_miniroot(iscsi_hba_t * ihp)5486 iscsi_check_miniroot(iscsi_hba_t *ihp)
5487 {
5488 	if (strncmp(rootfs.bo_name, "/ramdisk", 8) == 0) {
5489 		/*
5490 		 * in miniroot we don't have the persistent store
5491 		 * so just to need to ensure an enabled status
5492 		 */
5493 		ihp->hba_service_status = ISCSI_SERVICE_ENABLED;
5494 	}
5495 }
5496 
5497 static void
iscsi_get_tunable_default(iscsi_tunable_object_t * param)5498 iscsi_get_tunable_default(iscsi_tunable_object_t *param)
5499 {
5500 	int	param_id = 0;
5501 
5502 	param_id = 1 << (param->t_param - 1);
5503 	param->t_set = B_FALSE;
5504 	switch (param_id) {
5505 	case ISCSI_TUNABLE_PARAM_RX_TIMEOUT_VALUE:
5506 		param->t_value.v_integer = ISCSI_DEFAULT_RX_TIMEOUT_VALUE;
5507 		break;
5508 	case ISCSI_TUNABLE_PARAM_LOGIN_POLLING_DELAY:
5509 		param->t_value.v_integer = ISCSI_DEFAULT_LOGIN_POLLING_DELAY;
5510 		break;
5511 	case ISCSI_TUNABLE_PARAM_CONN_LOGIN_MAX:
5512 		param->t_value.v_integer = ISCSI_DEFAULT_CONN_DEFAULT_LOGIN_MAX;
5513 		break;
5514 	default:
5515 		break;
5516 	}
5517 }
5518 
5519 /*
5520  * iscsi_get_persisted_tunable_param * - a helper to ISCSI_TUNABLE_PARAM_GET
5521  * ioctl
5522  * return:
5523  *    0		persisted tunable parameter found
5524  *    1		persisted tunable parameter not found
5525  */
5526 static int
iscsi_get_persisted_tunable_param(uchar_t * name,iscsi_tunable_object_t * tpsg)5527 iscsi_get_persisted_tunable_param(uchar_t *name, iscsi_tunable_object_t *tpsg)
5528 {
5529 	int rtn = 1;
5530 	int param_id = 0;
5531 	persistent_tunable_param_t *pparam;
5532 
5533 	if ((name == NULL) || strlen((char *)name) == 0) {
5534 		return (rtn);
5535 	}
5536 
5537 	tpsg->t_set = B_FALSE;
5538 	pparam = (persistent_tunable_param_t *)kmem_zalloc(sizeof (*pparam),
5539 	    KM_SLEEP);
5540 	if (persistent_get_tunable_param((char *)name, pparam) == B_TRUE) {
5541 		if (pparam->p_bitmap & (1 << (tpsg->t_param - 1))) {
5542 			tpsg->t_set = B_TRUE;
5543 			param_id = 1 << (tpsg->t_param - 1);
5544 			switch (param_id) {
5545 			case ISCSI_TUNABLE_PARAM_RX_TIMEOUT_VALUE:
5546 				tpsg->t_value.v_integer =
5547 				    pparam->p_params.recv_login_rsp_timeout;
5548 				break;
5549 			case ISCSI_TUNABLE_PARAM_LOGIN_POLLING_DELAY:
5550 				tpsg->t_value.v_integer =
5551 				    pparam->p_params.polling_login_delay;
5552 				break;
5553 			case ISCSI_TUNABLE_PARAM_CONN_LOGIN_MAX:
5554 				tpsg->t_value.v_integer =
5555 				    pparam->p_params.conn_login_max;
5556 				break;
5557 			default:
5558 				break;
5559 			}
5560 			rtn = 0;
5561 		}
5562 	}
5563 
5564 	kmem_free(pparam, sizeof (*pparam));
5565 
5566 	return (rtn);
5567 }
5568