1a6d42e7dSPeter Dunlap /*
2a6d42e7dSPeter Dunlap  * CDDL HEADER START
3a6d42e7dSPeter Dunlap  *
4a6d42e7dSPeter Dunlap  * The contents of this file are subject to the terms of the
5a6d42e7dSPeter Dunlap  * Common Development and Distribution License (the "License").
6a6d42e7dSPeter Dunlap  * You may not use this file except in compliance with the License.
7a6d42e7dSPeter Dunlap  *
8a6d42e7dSPeter Dunlap  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9a6d42e7dSPeter Dunlap  * or http://www.opensolaris.org/os/licensing.
10a6d42e7dSPeter Dunlap  * See the License for the specific language governing permissions
11a6d42e7dSPeter Dunlap  * and limitations under the License.
12a6d42e7dSPeter Dunlap  *
13a6d42e7dSPeter Dunlap  * When distributing Covered Code, include this CDDL HEADER in each
14a6d42e7dSPeter Dunlap  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15a6d42e7dSPeter Dunlap  * If applicable, add the following below this CDDL HEADER, with the
16a6d42e7dSPeter Dunlap  * fields enclosed by brackets "[]" replaced with your own identifying
17a6d42e7dSPeter Dunlap  * information: Portions Copyright [yyyy] [name of copyright owner]
18a6d42e7dSPeter Dunlap  *
19a6d42e7dSPeter Dunlap  * CDDL HEADER END
20a6d42e7dSPeter Dunlap  */
21a6d42e7dSPeter Dunlap /*
22*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23a6d42e7dSPeter Dunlap  * Use is subject to license terms.
24a6d42e7dSPeter Dunlap  */
25a6d42e7dSPeter Dunlap 
26a6d42e7dSPeter Dunlap #include <sys/cpuvar.h>
27a6d42e7dSPeter Dunlap #include <sys/types.h>
28a6d42e7dSPeter Dunlap #include <sys/conf.h>
29a6d42e7dSPeter Dunlap #include <sys/stat.h>
30a6d42e7dSPeter Dunlap #include <sys/file.h>
31a6d42e7dSPeter Dunlap #include <sys/ddi.h>
32a6d42e7dSPeter Dunlap #include <sys/sunddi.h>
33a6d42e7dSPeter Dunlap #include <sys/modctl.h>
34a6d42e7dSPeter Dunlap #include <sys/sysmacros.h>
35a6d42e7dSPeter Dunlap #include <sys/socket.h>
36a6d42e7dSPeter Dunlap #include <sys/strsubr.h>
37a6d42e7dSPeter Dunlap #include <sys/nvpair.h>
38a6d42e7dSPeter Dunlap 
39a6d42e7dSPeter Dunlap #include <sys/stmf.h>
40a6d42e7dSPeter Dunlap #include <sys/stmf_ioctl.h>
41a6d42e7dSPeter Dunlap #include <sys/portif.h>
42a6d42e7dSPeter Dunlap #include <sys/idm/idm.h>
43a6d42e7dSPeter Dunlap #include <sys/idm/idm_conn_sm.h>
44a6d42e7dSPeter Dunlap #include <iscsit_isns.h>
45a6d42e7dSPeter Dunlap #include <iscsit.h>
46a6d42e7dSPeter Dunlap 
47a6d42e7dSPeter Dunlap #define	ISCSIT_VERSION		BUILD_DATE "-1.18dev"
48a6d42e7dSPeter Dunlap #define	ISCSIT_NAME_VERSION	"COMSTAR ISCSIT v" ISCSIT_VERSION
49a6d42e7dSPeter Dunlap 
50a6d42e7dSPeter Dunlap /*
51a6d42e7dSPeter Dunlap  * DDI entry points.
52a6d42e7dSPeter Dunlap  */
53a6d42e7dSPeter Dunlap static int iscsit_drv_attach(dev_info_t *, ddi_attach_cmd_t);
54a6d42e7dSPeter Dunlap static int iscsit_drv_detach(dev_info_t *, ddi_detach_cmd_t);
55a6d42e7dSPeter Dunlap static int iscsit_drv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
56a6d42e7dSPeter Dunlap static int iscsit_drv_open(dev_t *, int, int, cred_t *);
57a6d42e7dSPeter Dunlap static int iscsit_drv_close(dev_t, int, int, cred_t *);
58a6d42e7dSPeter Dunlap static boolean_t iscsit_drv_busy(void);
59a6d42e7dSPeter Dunlap static int iscsit_drv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
60a6d42e7dSPeter Dunlap 
61a6d42e7dSPeter Dunlap extern struct mod_ops mod_miscops;
62a6d42e7dSPeter Dunlap 
63a6d42e7dSPeter Dunlap 
64a6d42e7dSPeter Dunlap static struct cb_ops iscsit_cb_ops = {
65a6d42e7dSPeter Dunlap 	iscsit_drv_open,	/* cb_open */
66a6d42e7dSPeter Dunlap 	iscsit_drv_close,	/* cb_close */
67a6d42e7dSPeter Dunlap 	nodev,			/* cb_strategy */
68a6d42e7dSPeter Dunlap 	nodev,			/* cb_print */
69a6d42e7dSPeter Dunlap 	nodev,			/* cb_dump */
70a6d42e7dSPeter Dunlap 	nodev,			/* cb_read */
71a6d42e7dSPeter Dunlap 	nodev,			/* cb_write */
72a6d42e7dSPeter Dunlap 	iscsit_drv_ioctl,	/* cb_ioctl */
73a6d42e7dSPeter Dunlap 	nodev,			/* cb_devmap */
74a6d42e7dSPeter Dunlap 	nodev,			/* cb_mmap */
75a6d42e7dSPeter Dunlap 	nodev,			/* cb_segmap */
76a6d42e7dSPeter Dunlap 	nochpoll,		/* cb_chpoll */
77a6d42e7dSPeter Dunlap 	ddi_prop_op,		/* cb_prop_op */
78a6d42e7dSPeter Dunlap 	NULL,			/* cb_streamtab */
79a6d42e7dSPeter Dunlap 	D_MP,			/* cb_flag */
80a6d42e7dSPeter Dunlap 	CB_REV,			/* cb_rev */
81a6d42e7dSPeter Dunlap 	nodev,			/* cb_aread */
82a6d42e7dSPeter Dunlap 	nodev,			/* cb_awrite */
83a6d42e7dSPeter Dunlap };
84a6d42e7dSPeter Dunlap 
85a6d42e7dSPeter Dunlap static struct dev_ops iscsit_dev_ops = {
86a6d42e7dSPeter Dunlap 	DEVO_REV,		/* devo_rev */
87a6d42e7dSPeter Dunlap 	0,			/* devo_refcnt */
88a6d42e7dSPeter Dunlap 	iscsit_drv_getinfo,	/* devo_getinfo */
89a6d42e7dSPeter Dunlap 	nulldev,		/* devo_identify */
90a6d42e7dSPeter Dunlap 	nulldev,		/* devo_probe */
91a6d42e7dSPeter Dunlap 	iscsit_drv_attach,	/* devo_attach */
92a6d42e7dSPeter Dunlap 	iscsit_drv_detach,	/* devo_detach */
93a6d42e7dSPeter Dunlap 	nodev,			/* devo_reset */
94a6d42e7dSPeter Dunlap 	&iscsit_cb_ops,		/* devo_cb_ops */
95a6d42e7dSPeter Dunlap 	NULL,			/* devo_bus_ops */
96a6d42e7dSPeter Dunlap 	NULL,			/* devo_power */
9763528ae4SJames Moore 	ddi_quiesce_not_needed,	/* quiesce */
98a6d42e7dSPeter Dunlap };
99a6d42e7dSPeter Dunlap 
100a6d42e7dSPeter Dunlap static struct modldrv modldrv = {
101a6d42e7dSPeter Dunlap 	&mod_driverops,
102a6d42e7dSPeter Dunlap 	"iSCSI Target",
103a6d42e7dSPeter Dunlap 	&iscsit_dev_ops,
104a6d42e7dSPeter Dunlap };
105a6d42e7dSPeter Dunlap 
106a6d42e7dSPeter Dunlap static struct modlinkage modlinkage = {
107a6d42e7dSPeter Dunlap 	MODREV_1,
108a6d42e7dSPeter Dunlap 	&modldrv,
109a6d42e7dSPeter Dunlap 	NULL,
110a6d42e7dSPeter Dunlap };
111a6d42e7dSPeter Dunlap 
112a6d42e7dSPeter Dunlap 
113a6d42e7dSPeter Dunlap iscsit_global_t iscsit_global;
114a6d42e7dSPeter Dunlap 
115a6d42e7dSPeter Dunlap kmem_cache_t	*iscsit_status_pdu_cache;
116a6d42e7dSPeter Dunlap 
117a6d42e7dSPeter Dunlap boolean_t	iscsit_sm_logging = B_FALSE;
118a6d42e7dSPeter Dunlap 
119a6d42e7dSPeter Dunlap static idm_status_t iscsit_init(dev_info_t *dip);
120a6d42e7dSPeter Dunlap static idm_status_t iscsit_enable_svc(iscsit_hostinfo_t *hostinfo);
121a6d42e7dSPeter Dunlap static void iscsit_disable_svc(void);
122a6d42e7dSPeter Dunlap 
123a6d42e7dSPeter Dunlap static void
124a6d42e7dSPeter Dunlap iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
125a6d42e7dSPeter Dunlap 
126a6d42e7dSPeter Dunlap static void
127a6d42e7dSPeter Dunlap iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
128a6d42e7dSPeter Dunlap 
129a6d42e7dSPeter Dunlap static void
130a6d42e7dSPeter Dunlap iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
131a6d42e7dSPeter Dunlap 
132a6d42e7dSPeter Dunlap void
133a6d42e7dSPeter Dunlap iscsit_pdu_op_text_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
134a6d42e7dSPeter Dunlap 
135a6d42e7dSPeter Dunlap static void
136a6d42e7dSPeter Dunlap iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
137a6d42e7dSPeter Dunlap 
138a6d42e7dSPeter Dunlap int iscsit_cmd_window();
139a6d42e7dSPeter Dunlap 
140a6d42e7dSPeter Dunlap void
141a6d42e7dSPeter Dunlap iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu);
142a6d42e7dSPeter Dunlap 
143a6d42e7dSPeter Dunlap static void
144a6d42e7dSPeter Dunlap iscsit_deferred_dispatch(idm_pdu_t *rx_pdu);
145a6d42e7dSPeter Dunlap 
146a6d42e7dSPeter Dunlap static void
147a6d42e7dSPeter Dunlap iscsit_deferred(void *rx_pdu_void);
148a6d42e7dSPeter Dunlap 
149a6d42e7dSPeter Dunlap static idm_status_t
150a6d42e7dSPeter Dunlap iscsit_conn_accept(idm_conn_t *ic);
151a6d42e7dSPeter Dunlap 
152a6d42e7dSPeter Dunlap static idm_status_t
153a6d42e7dSPeter Dunlap iscsit_ffp_enabled(idm_conn_t *ic);
154a6d42e7dSPeter Dunlap 
155a6d42e7dSPeter Dunlap static idm_status_t
156a6d42e7dSPeter Dunlap iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class);
157a6d42e7dSPeter Dunlap 
158a6d42e7dSPeter Dunlap static idm_status_t
159a6d42e7dSPeter Dunlap iscsit_conn_lost(idm_conn_t *ic);
160a6d42e7dSPeter Dunlap 
161a6d42e7dSPeter Dunlap static idm_status_t
162a6d42e7dSPeter Dunlap iscsit_conn_destroy(idm_conn_t *ic);
163a6d42e7dSPeter Dunlap 
164a6d42e7dSPeter Dunlap static stmf_data_buf_t *
165a6d42e7dSPeter Dunlap iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize,
166a6d42e7dSPeter Dunlap     uint32_t flags);
167a6d42e7dSPeter Dunlap 
168a6d42e7dSPeter Dunlap static void
169a6d42e7dSPeter Dunlap iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf);
170a6d42e7dSPeter Dunlap 
171a6d42e7dSPeter Dunlap static void
172a6d42e7dSPeter Dunlap iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status);
173a6d42e7dSPeter Dunlap 
174a6d42e7dSPeter Dunlap static void
175a6d42e7dSPeter Dunlap iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status);
176a6d42e7dSPeter Dunlap 
177a6d42e7dSPeter Dunlap static void
178a6d42e7dSPeter Dunlap iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status);
179a6d42e7dSPeter Dunlap 
180a6d42e7dSPeter Dunlap static stmf_status_t
181a6d42e7dSPeter Dunlap iscsit_idm_to_stmf(idm_status_t idmrc);
182a6d42e7dSPeter Dunlap 
183a6d42e7dSPeter Dunlap static iscsit_task_t *
184a6d42e7dSPeter Dunlap iscsit_task_alloc(iscsit_conn_t *ict);
185a6d42e7dSPeter Dunlap 
186a6d42e7dSPeter Dunlap static void
187a6d42e7dSPeter Dunlap iscsit_task_free(iscsit_task_t *itask);
188a6d42e7dSPeter Dunlap 
189a6d42e7dSPeter Dunlap static iscsit_task_t *
190a6d42e7dSPeter Dunlap iscsit_tm_task_alloc(iscsit_conn_t *ict);
191a6d42e7dSPeter Dunlap 
192a6d42e7dSPeter Dunlap static void
193a6d42e7dSPeter Dunlap iscsit_tm_task_free(iscsit_task_t *itask);
194a6d42e7dSPeter Dunlap 
19572cf3143Speter dunlap static idm_status_t
19672cf3143Speter dunlap iscsit_task_start(iscsit_task_t *itask);
19772cf3143Speter dunlap 
19872cf3143Speter dunlap static void
19972cf3143Speter dunlap iscsit_task_done(iscsit_task_t *itask);
20072cf3143Speter dunlap 
201a6d42e7dSPeter Dunlap static int
202a6d42e7dSPeter Dunlap iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags);
203a6d42e7dSPeter Dunlap 
204a6d42e7dSPeter Dunlap static void
205a6d42e7dSPeter Dunlap iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags);
206a6d42e7dSPeter Dunlap 
207a6d42e7dSPeter Dunlap static it_cfg_status_t
208a6d42e7dSPeter Dunlap iscsit_config_merge(it_config_t *cfg);
209a6d42e7dSPeter Dunlap 
210a6d42e7dSPeter Dunlap static idm_status_t
211a6d42e7dSPeter Dunlap iscsit_login_fail(idm_conn_t *ic);
212a6d42e7dSPeter Dunlap 
21372cf3143Speter dunlap static boolean_t iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn);
21472cf3143Speter dunlap static void iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu,
21572cf3143Speter dunlap     uint8_t response, uint8_t cmd_status);
21672cf3143Speter dunlap static void iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu,
21772cf3143Speter dunlap     uint8_t tm_status);
21872cf3143Speter dunlap 
219a6d42e7dSPeter Dunlap int
220a6d42e7dSPeter Dunlap _init(void)
221a6d42e7dSPeter Dunlap {
222a6d42e7dSPeter Dunlap 	int rc;
223a6d42e7dSPeter Dunlap 
224a6d42e7dSPeter Dunlap 	rw_init(&iscsit_global.global_rwlock, NULL, RW_DRIVER, NULL);
225*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_init(&iscsit_global.global_state_mutex, NULL,
226*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    MUTEX_DRIVER, NULL);
227a6d42e7dSPeter Dunlap 	iscsit_global.global_svc_state = ISE_DETACHED;
228a6d42e7dSPeter Dunlap 
229a6d42e7dSPeter Dunlap 	if ((rc = mod_install(&modlinkage)) != 0) {
230*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_destroy(&iscsit_global.global_state_mutex);
231a6d42e7dSPeter Dunlap 		rw_destroy(&iscsit_global.global_rwlock);
232a6d42e7dSPeter Dunlap 		return (rc);
233a6d42e7dSPeter Dunlap 	}
234a6d42e7dSPeter Dunlap 
235a6d42e7dSPeter Dunlap 	return (rc);
236a6d42e7dSPeter Dunlap }
237a6d42e7dSPeter Dunlap 
238a6d42e7dSPeter Dunlap int
239a6d42e7dSPeter Dunlap _info(struct modinfo *modinfop)
240a6d42e7dSPeter Dunlap {
241a6d42e7dSPeter Dunlap 	return (mod_info(&modlinkage, modinfop));
242a6d42e7dSPeter Dunlap }
243a6d42e7dSPeter Dunlap 
244a6d42e7dSPeter Dunlap int
245a6d42e7dSPeter Dunlap _fini(void)
246a6d42e7dSPeter Dunlap {
247a6d42e7dSPeter Dunlap 	int rc;
248a6d42e7dSPeter Dunlap 
249a6d42e7dSPeter Dunlap 	rc = mod_remove(&modlinkage);
250a6d42e7dSPeter Dunlap 
251a6d42e7dSPeter Dunlap 	if (rc == 0) {
252*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_destroy(&iscsit_global.global_state_mutex);
253a6d42e7dSPeter Dunlap 		rw_destroy(&iscsit_global.global_rwlock);
254a6d42e7dSPeter Dunlap 	}
255a6d42e7dSPeter Dunlap 
256a6d42e7dSPeter Dunlap 	return (rc);
257a6d42e7dSPeter Dunlap }
258a6d42e7dSPeter Dunlap 
259a6d42e7dSPeter Dunlap /*
260a6d42e7dSPeter Dunlap  * DDI entry points.
261a6d42e7dSPeter Dunlap  */
262a6d42e7dSPeter Dunlap 
263a6d42e7dSPeter Dunlap /* ARGSUSED */
264a6d42e7dSPeter Dunlap static int
265a6d42e7dSPeter Dunlap iscsit_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
266a6d42e7dSPeter Dunlap     void **result)
267a6d42e7dSPeter Dunlap {
268a6d42e7dSPeter Dunlap 	ulong_t instance = getminor((dev_t)arg);
269a6d42e7dSPeter Dunlap 
270a6d42e7dSPeter Dunlap 	switch (cmd) {
271a6d42e7dSPeter Dunlap 	case DDI_INFO_DEVT2DEVINFO:
272a6d42e7dSPeter Dunlap 		*result = iscsit_global.global_dip;
273a6d42e7dSPeter Dunlap 		return (DDI_SUCCESS);
274a6d42e7dSPeter Dunlap 
275a6d42e7dSPeter Dunlap 	case DDI_INFO_DEVT2INSTANCE:
276a6d42e7dSPeter Dunlap 		*result = (void *)instance;
277a6d42e7dSPeter Dunlap 		return (DDI_SUCCESS);
278a6d42e7dSPeter Dunlap 
279a6d42e7dSPeter Dunlap 	default:
280a6d42e7dSPeter Dunlap 		break;
281a6d42e7dSPeter Dunlap 	}
282a6d42e7dSPeter Dunlap 
283a6d42e7dSPeter Dunlap 	return (DDI_FAILURE);
284a6d42e7dSPeter Dunlap }
285a6d42e7dSPeter Dunlap 
286a6d42e7dSPeter Dunlap static int
287a6d42e7dSPeter Dunlap iscsit_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
288a6d42e7dSPeter Dunlap {
289a6d42e7dSPeter Dunlap 	if (cmd != DDI_ATTACH) {
290a6d42e7dSPeter Dunlap 		return (DDI_FAILURE);
291a6d42e7dSPeter Dunlap 	}
292a6d42e7dSPeter Dunlap 
293a6d42e7dSPeter Dunlap 	if (ddi_get_instance(dip) != 0) {
294a6d42e7dSPeter Dunlap 		/* we only allow instance 0 to attach */
295a6d42e7dSPeter Dunlap 		return (DDI_FAILURE);
296a6d42e7dSPeter Dunlap 	}
297a6d42e7dSPeter Dunlap 
298a6d42e7dSPeter Dunlap 	/* create the minor node */
299a6d42e7dSPeter Dunlap 	if (ddi_create_minor_node(dip, ISCSIT_MODNAME, S_IFCHR, 0,
300a6d42e7dSPeter Dunlap 	    DDI_PSEUDO, 0) != DDI_SUCCESS) {
301a6d42e7dSPeter Dunlap 		cmn_err(CE_WARN, "iscsit_drv_attach: "
302a6d42e7dSPeter Dunlap 		    "failed creating minor node");
303a6d42e7dSPeter Dunlap 		return (DDI_FAILURE);
304a6d42e7dSPeter Dunlap 	}
305a6d42e7dSPeter Dunlap 
306a6d42e7dSPeter Dunlap 	if (iscsit_init(dip) != IDM_STATUS_SUCCESS) {
307a6d42e7dSPeter Dunlap 		cmn_err(CE_WARN, "iscsit_drv_attach: "
308a6d42e7dSPeter Dunlap 		    "failed to initialize");
309a6d42e7dSPeter Dunlap 		ddi_remove_minor_node(dip, NULL);
310a6d42e7dSPeter Dunlap 		return (DDI_FAILURE);
311a6d42e7dSPeter Dunlap 	}
312a6d42e7dSPeter Dunlap 
313a6d42e7dSPeter Dunlap 	iscsit_global.global_svc_state = ISE_DISABLED;
314a6d42e7dSPeter Dunlap 	iscsit_global.global_dip = dip;
315a6d42e7dSPeter Dunlap 
316a6d42e7dSPeter Dunlap 	return (DDI_SUCCESS);
317a6d42e7dSPeter Dunlap }
318a6d42e7dSPeter Dunlap 
319a6d42e7dSPeter Dunlap /*ARGSUSED*/
320a6d42e7dSPeter Dunlap static int
321a6d42e7dSPeter Dunlap iscsit_drv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
322a6d42e7dSPeter Dunlap {
323a6d42e7dSPeter Dunlap 	if (cmd != DDI_DETACH)
324a6d42e7dSPeter Dunlap 		return (DDI_FAILURE);
325a6d42e7dSPeter Dunlap 
326*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	/*
327*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * drv_detach is called in a context that owns the
328*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * device node for the /dev/pseudo device.  If this thread blocks
329*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * for any resource, other threads that need the /dev/pseudo device
330*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * may end up in a deadlock with this thread.Hence, we use a
331*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * separate lock just for the structures that drv_detach needs
332*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * to access.
333*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 */
334*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_enter(&iscsit_global.global_state_mutex);
335a6d42e7dSPeter Dunlap 	if (iscsit_drv_busy()) {
336*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
337a6d42e7dSPeter Dunlap 		return (EBUSY);
338a6d42e7dSPeter Dunlap 	}
339a6d42e7dSPeter Dunlap 
340a6d42e7dSPeter Dunlap 	iscsit_global.global_dip = NULL;
341a6d42e7dSPeter Dunlap 	ddi_remove_minor_node(dip, NULL);
342a6d42e7dSPeter Dunlap 
343a6d42e7dSPeter Dunlap 	ldi_ident_release(iscsit_global.global_li);
344a6d42e7dSPeter Dunlap 	iscsit_global.global_svc_state = ISE_DETACHED;
345a6d42e7dSPeter Dunlap 
346*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_exit(&iscsit_global.global_state_mutex);
347a6d42e7dSPeter Dunlap 
348a6d42e7dSPeter Dunlap 	return (DDI_SUCCESS);
349a6d42e7dSPeter Dunlap }
350a6d42e7dSPeter Dunlap 
351a6d42e7dSPeter Dunlap /*ARGSUSED*/
352a6d42e7dSPeter Dunlap static int
353a6d42e7dSPeter Dunlap iscsit_drv_open(dev_t *devp, int flag, int otyp, cred_t *credp)
354a6d42e7dSPeter Dunlap {
355a6d42e7dSPeter Dunlap 	return (0);
356a6d42e7dSPeter Dunlap }
357a6d42e7dSPeter Dunlap 
358a6d42e7dSPeter Dunlap /* ARGSUSED */
359a6d42e7dSPeter Dunlap static int
360a6d42e7dSPeter Dunlap iscsit_drv_close(dev_t dev, int flag, int otyp, cred_t *credp)
361a6d42e7dSPeter Dunlap {
362a6d42e7dSPeter Dunlap 	return (0);
363a6d42e7dSPeter Dunlap }
364a6d42e7dSPeter Dunlap 
365a6d42e7dSPeter Dunlap static boolean_t
366a6d42e7dSPeter Dunlap iscsit_drv_busy(void)
367a6d42e7dSPeter Dunlap {
368*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	ASSERT(MUTEX_HELD(&iscsit_global.global_state_mutex));
369*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
370a6d42e7dSPeter Dunlap 	switch (iscsit_global.global_svc_state) {
371a6d42e7dSPeter Dunlap 	case ISE_DISABLED:
372a6d42e7dSPeter Dunlap 	case ISE_DETACHED:
373a6d42e7dSPeter Dunlap 		return (B_FALSE);
374a6d42e7dSPeter Dunlap 	default:
375a6d42e7dSPeter Dunlap 		return (B_TRUE);
376a6d42e7dSPeter Dunlap 	}
377a6d42e7dSPeter Dunlap 	/* NOTREACHED */
378a6d42e7dSPeter Dunlap }
379a6d42e7dSPeter Dunlap 
380a6d42e7dSPeter Dunlap /* ARGSUSED */
381a6d42e7dSPeter Dunlap static int
382a6d42e7dSPeter Dunlap iscsit_drv_ioctl(dev_t drv, int cmd, intptr_t argp, int flag, cred_t *cred,
383a6d42e7dSPeter Dunlap     int *retval)
384a6d42e7dSPeter Dunlap {
385a6d42e7dSPeter Dunlap 	iscsit_ioc_set_config_t		setcfg;
386a6d42e7dSPeter Dunlap 	iscsit_ioc_set_config32_t	setcfg32;
38707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	char				*cfg_pnvlist = NULL;
38807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	nvlist_t			*cfg_nvlist = NULL;
38907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	it_config_t			*cfg = NULL;
390a6d42e7dSPeter Dunlap 	idm_status_t			idmrc;
391a6d42e7dSPeter Dunlap 	int				rc = 0;
392a6d42e7dSPeter Dunlap 
393a6d42e7dSPeter Dunlap 	if (drv_priv(cred) != 0) {
394a6d42e7dSPeter Dunlap 		return (EPERM);
395a6d42e7dSPeter Dunlap 	}
396a6d42e7dSPeter Dunlap 
397*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_enter(&iscsit_global.global_state_mutex);
398a6d42e7dSPeter Dunlap 
399a6d42e7dSPeter Dunlap 	/*
400a6d42e7dSPeter Dunlap 	 * Validate ioctl requests against global service state
401a6d42e7dSPeter Dunlap 	 */
402a6d42e7dSPeter Dunlap 	switch (iscsit_global.global_svc_state) {
403a6d42e7dSPeter Dunlap 	case ISE_ENABLED:
404a6d42e7dSPeter Dunlap 		if (cmd == ISCSIT_IOC_DISABLE_SVC) {
405a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_DISABLING;
406a6d42e7dSPeter Dunlap 		} else if (cmd == ISCSIT_IOC_ENABLE_SVC) {
407a6d42e7dSPeter Dunlap 			/* Already enabled */
408*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_exit(&iscsit_global.global_state_mutex);
409a6d42e7dSPeter Dunlap 			return (0);
410a6d42e7dSPeter Dunlap 		} else {
411a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_BUSY;
412a6d42e7dSPeter Dunlap 		}
413a6d42e7dSPeter Dunlap 		break;
414a6d42e7dSPeter Dunlap 	case ISE_DISABLED:
415a6d42e7dSPeter Dunlap 		if (cmd == ISCSIT_IOC_ENABLE_SVC) {
416a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_ENABLING;
417a6d42e7dSPeter Dunlap 		} else if (cmd == ISCSIT_IOC_DISABLE_SVC) {
418a6d42e7dSPeter Dunlap 			/* Already disabled */
419*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_exit(&iscsit_global.global_state_mutex);
420a6d42e7dSPeter Dunlap 			return (0);
421a6d42e7dSPeter Dunlap 		} else {
422a6d42e7dSPeter Dunlap 			rc = EFAULT;
423a6d42e7dSPeter Dunlap 		}
424a6d42e7dSPeter Dunlap 		break;
425*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	case ISE_BUSY:
426a6d42e7dSPeter Dunlap 	case ISE_ENABLING:
427a6d42e7dSPeter Dunlap 	case ISE_DISABLING:
428a6d42e7dSPeter Dunlap 		rc = EAGAIN;
429a6d42e7dSPeter Dunlap 		break;
430a6d42e7dSPeter Dunlap 	case ISE_DETACHED:
431a6d42e7dSPeter Dunlap 	default:
432a6d42e7dSPeter Dunlap 		rc = EFAULT;
433a6d42e7dSPeter Dunlap 		break;
434a6d42e7dSPeter Dunlap 	}
435a6d42e7dSPeter Dunlap 
436*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_exit(&iscsit_global.global_state_mutex);
437a6d42e7dSPeter Dunlap 	if (rc != 0)
438a6d42e7dSPeter Dunlap 		return (rc);
439a6d42e7dSPeter Dunlap 
440a6d42e7dSPeter Dunlap 	/* Handle ioctl request (enable/disable have already been handled) */
441a6d42e7dSPeter Dunlap 	switch (cmd) {
442a6d42e7dSPeter Dunlap 	case ISCSIT_IOC_SET_CONFIG:
44307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		/* Any errors must set state back to ISE_ENABLED */
444a6d42e7dSPeter Dunlap 		switch (ddi_model_convert_from(flag & FMODELS)) {
445a6d42e7dSPeter Dunlap 		case DDI_MODEL_ILP32:
446a6d42e7dSPeter Dunlap 			if (ddi_copyin((void *)argp, &setcfg32,
44707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			    sizeof (iscsit_ioc_set_config32_t), flag) != 0) {
44807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				rc = EFAULT;
44907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				goto cleanup;
45007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			}
451a6d42e7dSPeter Dunlap 
452a6d42e7dSPeter Dunlap 			setcfg.set_cfg_pnvlist =
453a6d42e7dSPeter Dunlap 			    (char *)((uintptr_t)setcfg32.set_cfg_pnvlist);
454a6d42e7dSPeter Dunlap 			setcfg.set_cfg_vers = setcfg32.set_cfg_vers;
455a6d42e7dSPeter Dunlap 			setcfg.set_cfg_pnvlist_len =
456a6d42e7dSPeter Dunlap 			    setcfg32.set_cfg_pnvlist_len;
457a6d42e7dSPeter Dunlap 			break;
458a6d42e7dSPeter Dunlap 		case DDI_MODEL_NONE:
459a6d42e7dSPeter Dunlap 			if (ddi_copyin((void *)argp, &setcfg,
46007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			    sizeof (iscsit_ioc_set_config_t), flag) != 0) {
46107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				rc = EFAULT;
46207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				goto cleanup;
46307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			}
464a6d42e7dSPeter Dunlap 			break;
465fcc214c3SCharles Ting 		default:
466fcc214c3SCharles Ting 			rc = EFAULT;
467fcc214c3SCharles Ting 			goto cleanup;
468a6d42e7dSPeter Dunlap 		}
469a6d42e7dSPeter Dunlap 
470a6d42e7dSPeter Dunlap 		/* Check API version */
471a6d42e7dSPeter Dunlap 		if (setcfg.set_cfg_vers != ISCSIT_API_VERS0) {
47207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			rc = EINVAL;
47307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			goto cleanup;
474a6d42e7dSPeter Dunlap 		}
475a6d42e7dSPeter Dunlap 
476a6d42e7dSPeter Dunlap 		/* Config is in packed nvlist format so unpack it */
477a6d42e7dSPeter Dunlap 		cfg_pnvlist = kmem_alloc(setcfg.set_cfg_pnvlist_len,
478a6d42e7dSPeter Dunlap 		    KM_SLEEP);
479a6d42e7dSPeter Dunlap 		ASSERT(cfg_pnvlist != NULL);
480a6d42e7dSPeter Dunlap 
481a6d42e7dSPeter Dunlap 		if (ddi_copyin(setcfg.set_cfg_pnvlist, cfg_pnvlist,
482a6d42e7dSPeter Dunlap 		    setcfg.set_cfg_pnvlist_len, flag) != 0) {
48307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			rc = EFAULT;
48407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			goto cleanup;
485a6d42e7dSPeter Dunlap 		}
486a6d42e7dSPeter Dunlap 
48707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		rc = nvlist_unpack(cfg_pnvlist, setcfg.set_cfg_pnvlist_len,
48807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		    &cfg_nvlist, KM_SLEEP);
48907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (rc != 0) {
49007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			goto cleanup;
491a6d42e7dSPeter Dunlap 		}
492a6d42e7dSPeter Dunlap 
493a6d42e7dSPeter Dunlap 		/* Translate nvlist */
49407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		rc = it_nv_to_config(cfg_nvlist, &cfg);
49507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (rc != 0) {
496a6d42e7dSPeter Dunlap 			cmn_err(CE_WARN, "Configuration is invalid");
49707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			goto cleanup;
498a6d42e7dSPeter Dunlap 		}
499a6d42e7dSPeter Dunlap 
500a6d42e7dSPeter Dunlap 		/* Update config */
50107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		rc = iscsit_config_merge(cfg);
50207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		/* FALLTHROUGH */
50307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
50407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States cleanup:
50507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (cfg)
50607a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			it_config_free_cmn(cfg);
50707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (cfg_pnvlist)
508a6d42e7dSPeter Dunlap 			kmem_free(cfg_pnvlist, setcfg.set_cfg_pnvlist_len);
50907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		if (cfg_nvlist)
510a6d42e7dSPeter Dunlap 			nvlist_free(cfg_nvlist);
511a6d42e7dSPeter Dunlap 
512a6d42e7dSPeter Dunlap 		/*
513a6d42e7dSPeter Dunlap 		 * Now that the reconfig is complete set our state back to
514a6d42e7dSPeter Dunlap 		 * enabled.
515a6d42e7dSPeter Dunlap 		 */
516*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_enter(&iscsit_global.global_state_mutex);
517a6d42e7dSPeter Dunlap 		iscsit_global.global_svc_state = ISE_ENABLED;
518*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
519a6d42e7dSPeter Dunlap 		break;
520a6d42e7dSPeter Dunlap 	case ISCSIT_IOC_ENABLE_SVC: {
521a6d42e7dSPeter Dunlap 		iscsit_hostinfo_t hostinfo;
522a6d42e7dSPeter Dunlap 
523a6d42e7dSPeter Dunlap 		if (ddi_copyin((void *)argp, &hostinfo.length,
524a6d42e7dSPeter Dunlap 		    sizeof (hostinfo.length), flag) != 0) {
525*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_enter(&iscsit_global.global_state_mutex);
526a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_DISABLED;
527*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_exit(&iscsit_global.global_state_mutex);
528a6d42e7dSPeter Dunlap 			return (EFAULT);
529a6d42e7dSPeter Dunlap 		}
530a6d42e7dSPeter Dunlap 
531a6d42e7dSPeter Dunlap 		if (hostinfo.length > sizeof (hostinfo.fqhn))
532a6d42e7dSPeter Dunlap 			hostinfo.length = sizeof (hostinfo.fqhn);
533a6d42e7dSPeter Dunlap 
534a6d42e7dSPeter Dunlap 		if (ddi_copyin((void *)((caddr_t)argp +
535a6d42e7dSPeter Dunlap 		    sizeof (hostinfo.length)), &hostinfo.fqhn,
536a6d42e7dSPeter Dunlap 		    hostinfo.length, flag) != 0) {
537*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_enter(&iscsit_global.global_state_mutex);
538a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_DISABLED;
539*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_exit(&iscsit_global.global_state_mutex);
540a6d42e7dSPeter Dunlap 			return (EFAULT);
541a6d42e7dSPeter Dunlap 		}
542a6d42e7dSPeter Dunlap 
543a6d42e7dSPeter Dunlap 		idmrc = iscsit_enable_svc(&hostinfo);
544*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_enter(&iscsit_global.global_state_mutex);
545a6d42e7dSPeter Dunlap 		if (idmrc == IDM_STATUS_SUCCESS) {
546a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_ENABLED;
547a6d42e7dSPeter Dunlap 		} else {
548a6d42e7dSPeter Dunlap 			rc = EIO;
549a6d42e7dSPeter Dunlap 			iscsit_global.global_svc_state = ISE_DISABLED;
550a6d42e7dSPeter Dunlap 		}
551*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
552a6d42e7dSPeter Dunlap 		break;
553a6d42e7dSPeter Dunlap 	}
554a6d42e7dSPeter Dunlap 	case ISCSIT_IOC_DISABLE_SVC:
555a6d42e7dSPeter Dunlap 		iscsit_disable_svc();
556*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_enter(&iscsit_global.global_state_mutex);
557a6d42e7dSPeter Dunlap 		iscsit_global.global_svc_state = ISE_DISABLED;
558*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
559a6d42e7dSPeter Dunlap 		break;
56007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
561a6d42e7dSPeter Dunlap 	default:
562a6d42e7dSPeter Dunlap 		rc = EINVAL;
563*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_enter(&iscsit_global.global_state_mutex);
56407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		iscsit_global.global_svc_state = ISE_ENABLED;
565*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
566a6d42e7dSPeter Dunlap 	}
567a6d42e7dSPeter Dunlap 
568a6d42e7dSPeter Dunlap 	return (rc);
569a6d42e7dSPeter Dunlap }
570a6d42e7dSPeter Dunlap 
571a6d42e7dSPeter Dunlap static idm_status_t
572a6d42e7dSPeter Dunlap iscsit_init(dev_info_t *dip)
573a6d42e7dSPeter Dunlap {
574a6d42e7dSPeter Dunlap 	int			rc;
575a6d42e7dSPeter Dunlap 
576a6d42e7dSPeter Dunlap 	rc = ldi_ident_from_dip(dip, &iscsit_global.global_li);
577a6d42e7dSPeter Dunlap 	ASSERT(rc == 0);  /* Failure indicates invalid argument */
578a6d42e7dSPeter Dunlap 
579a6d42e7dSPeter Dunlap 	iscsit_global.global_svc_state = ISE_DISABLED;
580a6d42e7dSPeter Dunlap 
581a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
582a6d42e7dSPeter Dunlap }
583a6d42e7dSPeter Dunlap 
584a6d42e7dSPeter Dunlap /*
585a6d42e7dSPeter Dunlap  * iscsit_enable_svc
586a6d42e7dSPeter Dunlap  *
587a6d42e7dSPeter Dunlap  * registers all the configured targets and target portals with STMF
588a6d42e7dSPeter Dunlap  */
589a6d42e7dSPeter Dunlap static idm_status_t
590a6d42e7dSPeter Dunlap iscsit_enable_svc(iscsit_hostinfo_t *hostinfo)
591a6d42e7dSPeter Dunlap {
592a6d42e7dSPeter Dunlap 	stmf_port_provider_t	*pp;
593a6d42e7dSPeter Dunlap 	stmf_dbuf_store_t	*dbuf_store;
594a6d42e7dSPeter Dunlap 	boolean_t		did_iscsit_isns_init;
595a6d42e7dSPeter Dunlap 	idm_status_t		retval = IDM_STATUS_SUCCESS;
596a6d42e7dSPeter Dunlap 
597a6d42e7dSPeter Dunlap 	ASSERT(iscsit_global.global_svc_state == ISE_ENABLING);
598a6d42e7dSPeter Dunlap 
599a6d42e7dSPeter Dunlap 	/*
600a6d42e7dSPeter Dunlap 	 * Make sure that can tell if we have partially allocated
601a6d42e7dSPeter Dunlap 	 * in case we need to exit and tear down anything allocated.
602a6d42e7dSPeter Dunlap 	 */
603a6d42e7dSPeter Dunlap 	iscsit_global.global_tsih_pool = NULL;
604a6d42e7dSPeter Dunlap 	iscsit_global.global_dbuf_store = NULL;
605a6d42e7dSPeter Dunlap 	iscsit_status_pdu_cache = NULL;
606a6d42e7dSPeter Dunlap 	pp = NULL;
607a6d42e7dSPeter Dunlap 	iscsit_global.global_pp = NULL;
608a6d42e7dSPeter Dunlap 	iscsit_global.global_default_tpg = NULL;
609a6d42e7dSPeter Dunlap 	did_iscsit_isns_init = B_FALSE;
610a6d42e7dSPeter Dunlap 	iscsit_global.global_dispatch_taskq = NULL;
611a6d42e7dSPeter Dunlap 
612a6d42e7dSPeter Dunlap 	/* Setup remaining fields in iscsit_global_t */
613a6d42e7dSPeter Dunlap 	idm_refcnt_init(&iscsit_global.global_refcnt,
614a6d42e7dSPeter Dunlap 	    &iscsit_global);
615a6d42e7dSPeter Dunlap 
616a6d42e7dSPeter Dunlap 	avl_create(&iscsit_global.global_discovery_sessions,
617a6d42e7dSPeter Dunlap 	    iscsit_sess_avl_compare, sizeof (iscsit_sess_t),
618a6d42e7dSPeter Dunlap 	    offsetof(iscsit_sess_t, ist_tgt_ln));
619a6d42e7dSPeter Dunlap 
620a6d42e7dSPeter Dunlap 	avl_create(&iscsit_global.global_target_list,
621a6d42e7dSPeter Dunlap 	    iscsit_tgt_avl_compare, sizeof (iscsit_tgt_t),
622a6d42e7dSPeter Dunlap 	    offsetof(iscsit_tgt_t, target_global_ln));
623a6d42e7dSPeter Dunlap 
624a6d42e7dSPeter Dunlap 	list_create(&iscsit_global.global_deleted_target_list,
625a6d42e7dSPeter Dunlap 	    sizeof (iscsit_tgt_t),
626a6d42e7dSPeter Dunlap 	    offsetof(iscsit_tgt_t, target_global_deleted_ln));
627a6d42e7dSPeter Dunlap 
628a6d42e7dSPeter Dunlap 	avl_create(&iscsit_global.global_tpg_list,
629a6d42e7dSPeter Dunlap 	    iscsit_tpg_avl_compare, sizeof (iscsit_tpg_t),
630a6d42e7dSPeter Dunlap 	    offsetof(iscsit_tpg_t, tpg_global_ln));
631a6d42e7dSPeter Dunlap 
632a6d42e7dSPeter Dunlap 	avl_create(&iscsit_global.global_ini_list,
633a6d42e7dSPeter Dunlap 	    iscsit_ini_avl_compare, sizeof (iscsit_ini_t),
634a6d42e7dSPeter Dunlap 	    offsetof(iscsit_ini_t, ini_global_ln));
635a6d42e7dSPeter Dunlap 
636a6d42e7dSPeter Dunlap 	iscsit_global.global_tsih_pool = vmem_create("iscsit_tsih_pool",
637a6d42e7dSPeter Dunlap 	    (void *)1, ISCSI_MAX_TSIH, 1, NULL, NULL, NULL, 0,
638a6d42e7dSPeter Dunlap 	    VM_SLEEP | VMC_IDENTIFIER);
639a6d42e7dSPeter Dunlap 
640a6d42e7dSPeter Dunlap 	/*
641a6d42e7dSPeter Dunlap 	 * Setup STMF dbuf store.  Our buffers are bound to a specific
642a6d42e7dSPeter Dunlap 	 * connection so we really can't let STMF cache buffers for us.
643a6d42e7dSPeter Dunlap 	 * Consequently we'll just allocate one global buffer store.
644a6d42e7dSPeter Dunlap 	 */
645a6d42e7dSPeter Dunlap 	dbuf_store = stmf_alloc(STMF_STRUCT_DBUF_STORE, 0, 0);
646a6d42e7dSPeter Dunlap 	if (dbuf_store == NULL) {
647a6d42e7dSPeter Dunlap 		retval = IDM_STATUS_FAIL;
648a6d42e7dSPeter Dunlap 		goto tear_down_and_return;
649a6d42e7dSPeter Dunlap 	}
650a6d42e7dSPeter Dunlap 	dbuf_store->ds_alloc_data_buf = iscsit_dbuf_alloc;
651a6d42e7dSPeter Dunlap 	dbuf_store->ds_free_data_buf = iscsit_dbuf_free;
652a6d42e7dSPeter Dunlap 	dbuf_store->ds_port_private = NULL;
653a6d42e7dSPeter Dunlap 	iscsit_global.global_dbuf_store = dbuf_store;
654a6d42e7dSPeter Dunlap 
655a6d42e7dSPeter Dunlap 	/* Status PDU cache */
656a6d42e7dSPeter Dunlap 	iscsit_status_pdu_cache = kmem_cache_create("iscsit_status_pdu_cache",
657a6d42e7dSPeter Dunlap 	    sizeof (idm_pdu_t) + sizeof (iscsi_scsi_rsp_hdr_t), 8,
658a6d42e7dSPeter Dunlap 	    &iscsit_status_pdu_constructor,
659a6d42e7dSPeter Dunlap 	    NULL, NULL, NULL, NULL, KM_SLEEP);
660a6d42e7dSPeter Dunlap 
661a6d42e7dSPeter Dunlap 	/* Default TPG and portal */
662a6d42e7dSPeter Dunlap 	iscsit_global.global_default_tpg = iscsit_tpg_createdefault();
663a6d42e7dSPeter Dunlap 	if (iscsit_global.global_default_tpg == NULL) {
664a6d42e7dSPeter Dunlap 		retval = IDM_STATUS_FAIL;
665a6d42e7dSPeter Dunlap 		goto tear_down_and_return;
666a6d42e7dSPeter Dunlap 	}
667a6d42e7dSPeter Dunlap 
668a6d42e7dSPeter Dunlap 	/* initialize isns client */
669a6d42e7dSPeter Dunlap 	(void) iscsit_isns_init(hostinfo);
670a6d42e7dSPeter Dunlap 	did_iscsit_isns_init = B_TRUE;
671a6d42e7dSPeter Dunlap 
672a6d42e7dSPeter Dunlap 	/* Register port provider */
673a6d42e7dSPeter Dunlap 	pp = stmf_alloc(STMF_STRUCT_PORT_PROVIDER, 0, 0);
674a6d42e7dSPeter Dunlap 	if (pp == NULL) {
675a6d42e7dSPeter Dunlap 		retval = IDM_STATUS_FAIL;
676a6d42e7dSPeter Dunlap 		goto tear_down_and_return;
677a6d42e7dSPeter Dunlap 	}
678a6d42e7dSPeter Dunlap 
679a6d42e7dSPeter Dunlap 	pp->pp_portif_rev = PORTIF_REV_1;
680a6d42e7dSPeter Dunlap 	pp->pp_instance = 0;
681a6d42e7dSPeter Dunlap 	pp->pp_name = ISCSIT_MODNAME;
682a6d42e7dSPeter Dunlap 	pp->pp_cb = iscsit_pp_cb;
683a6d42e7dSPeter Dunlap 
684a6d42e7dSPeter Dunlap 	iscsit_global.global_pp = pp;
685a6d42e7dSPeter Dunlap 
686a6d42e7dSPeter Dunlap 
687a6d42e7dSPeter Dunlap 	if (stmf_register_port_provider(pp) != STMF_SUCCESS) {
688a6d42e7dSPeter Dunlap 		retval = IDM_STATUS_FAIL;
689a6d42e7dSPeter Dunlap 		goto tear_down_and_return;
690a6d42e7dSPeter Dunlap 	}
691a6d42e7dSPeter Dunlap 
692a6d42e7dSPeter Dunlap 	iscsit_global.global_dispatch_taskq = taskq_create("iscsit_dispatch",
693a6d42e7dSPeter Dunlap 	    1, minclsyspri, 16, 16, TASKQ_PREPOPULATE);
694a6d42e7dSPeter Dunlap 
695a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
696a6d42e7dSPeter Dunlap 
697a6d42e7dSPeter Dunlap tear_down_and_return:
698a6d42e7dSPeter Dunlap 
699a6d42e7dSPeter Dunlap 	if (iscsit_global.global_dispatch_taskq) {
700a6d42e7dSPeter Dunlap 		taskq_destroy(iscsit_global.global_dispatch_taskq);
701a6d42e7dSPeter Dunlap 		iscsit_global.global_dispatch_taskq = NULL;
702a6d42e7dSPeter Dunlap 	}
703a6d42e7dSPeter Dunlap 
704a6d42e7dSPeter Dunlap 	if (did_iscsit_isns_init)
705a6d42e7dSPeter Dunlap 		iscsit_isns_fini();
706a6d42e7dSPeter Dunlap 
707a6d42e7dSPeter Dunlap 	if (iscsit_global.global_default_tpg) {
708a6d42e7dSPeter Dunlap 		iscsit_tpg_destroydefault(iscsit_global.global_default_tpg);
709a6d42e7dSPeter Dunlap 		iscsit_global.global_default_tpg = NULL;
710a6d42e7dSPeter Dunlap 	}
711a6d42e7dSPeter Dunlap 
712a6d42e7dSPeter Dunlap 	if (iscsit_global.global_pp)
713a6d42e7dSPeter Dunlap 		iscsit_global.global_pp = NULL;
714a6d42e7dSPeter Dunlap 
715a6d42e7dSPeter Dunlap 	if (pp)
716a6d42e7dSPeter Dunlap 		stmf_free(pp);
717a6d42e7dSPeter Dunlap 
718a6d42e7dSPeter Dunlap 	if (iscsit_status_pdu_cache) {
719a6d42e7dSPeter Dunlap 		kmem_cache_destroy(iscsit_status_pdu_cache);
720a6d42e7dSPeter Dunlap 		iscsit_status_pdu_cache = NULL;
721a6d42e7dSPeter Dunlap 	}
722a6d42e7dSPeter Dunlap 
723a6d42e7dSPeter Dunlap 	if (iscsit_global.global_dbuf_store) {
724a6d42e7dSPeter Dunlap 		stmf_free(iscsit_global.global_dbuf_store);
725a6d42e7dSPeter Dunlap 		iscsit_global.global_dbuf_store = NULL;
726a6d42e7dSPeter Dunlap 	}
727a6d42e7dSPeter Dunlap 
728a6d42e7dSPeter Dunlap 	if (iscsit_global.global_tsih_pool) {
729a6d42e7dSPeter Dunlap 		vmem_destroy(iscsit_global.global_tsih_pool);
730a6d42e7dSPeter Dunlap 		iscsit_global.global_tsih_pool = NULL;
731a6d42e7dSPeter Dunlap 	}
732a6d42e7dSPeter Dunlap 
733a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_ini_list);
734a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_tpg_list);
735a6d42e7dSPeter Dunlap 	list_destroy(&iscsit_global.global_deleted_target_list);
736a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_target_list);
737a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_discovery_sessions);
738a6d42e7dSPeter Dunlap 
739a6d42e7dSPeter Dunlap 	idm_refcnt_destroy(&iscsit_global.global_refcnt);
740a6d42e7dSPeter Dunlap 
741a6d42e7dSPeter Dunlap 	return (retval);
742a6d42e7dSPeter Dunlap }
743a6d42e7dSPeter Dunlap 
744a6d42e7dSPeter Dunlap /*
745a6d42e7dSPeter Dunlap  * iscsit_disable_svc
746a6d42e7dSPeter Dunlap  *
747a6d42e7dSPeter Dunlap  * clean up all existing connections and deregister targets from STMF
748a6d42e7dSPeter Dunlap  */
749a6d42e7dSPeter Dunlap static void
750a6d42e7dSPeter Dunlap iscsit_disable_svc(void)
751a6d42e7dSPeter Dunlap {
752a6d42e7dSPeter Dunlap 	iscsit_sess_t	*sess;
753a6d42e7dSPeter Dunlap 
754a6d42e7dSPeter Dunlap 	ASSERT(iscsit_global.global_svc_state == ISE_DISABLING);
755a6d42e7dSPeter Dunlap 
756a6d42e7dSPeter Dunlap 	/* tear down discovery sessions */
757a6d42e7dSPeter Dunlap 	for (sess = avl_first(&iscsit_global.global_discovery_sessions);
758a6d42e7dSPeter Dunlap 	    sess != NULL;
759a6d42e7dSPeter Dunlap 	    sess = AVL_NEXT(&iscsit_global.global_discovery_sessions, sess))
760a6d42e7dSPeter Dunlap 		iscsit_sess_close(sess);
761a6d42e7dSPeter Dunlap 
762a6d42e7dSPeter Dunlap 	/*
763a6d42e7dSPeter Dunlap 	 * Passing NULL to iscsit_config_merge tells it to go to an empty
764a6d42e7dSPeter Dunlap 	 * config.
765a6d42e7dSPeter Dunlap 	 */
766a6d42e7dSPeter Dunlap 	(void) iscsit_config_merge(NULL);
767a6d42e7dSPeter Dunlap 
768a6d42e7dSPeter Dunlap 	/*
769a6d42e7dSPeter Dunlap 	 * Wait until there are no more global references
770a6d42e7dSPeter Dunlap 	 */
771a6d42e7dSPeter Dunlap 	idm_refcnt_wait_ref(&iscsit_global.global_refcnt);
772a6d42e7dSPeter Dunlap 	idm_refcnt_destroy(&iscsit_global.global_refcnt);
773a6d42e7dSPeter Dunlap 
774a6d42e7dSPeter Dunlap 	/*
775a6d42e7dSPeter Dunlap 	 * Default TPG must be destroyed after global_refcnt is 0.
776a6d42e7dSPeter Dunlap 	 */
777a6d42e7dSPeter Dunlap 	iscsit_tpg_destroydefault(iscsit_global.global_default_tpg);
778a6d42e7dSPeter Dunlap 
779a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_discovery_sessions);
780a6d42e7dSPeter Dunlap 	list_destroy(&iscsit_global.global_deleted_target_list);
781a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_target_list);
782a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_tpg_list);
783a6d42e7dSPeter Dunlap 	avl_destroy(&iscsit_global.global_ini_list);
784a6d42e7dSPeter Dunlap 
785a6d42e7dSPeter Dunlap 	taskq_destroy(iscsit_global.global_dispatch_taskq);
786a6d42e7dSPeter Dunlap 
787a6d42e7dSPeter Dunlap 	iscsit_isns_fini();
788a6d42e7dSPeter Dunlap 
789a6d42e7dSPeter Dunlap 	stmf_free(iscsit_global.global_dbuf_store);
790a6d42e7dSPeter Dunlap 	iscsit_global.global_dbuf_store = NULL;
791a6d42e7dSPeter Dunlap 
792a6d42e7dSPeter Dunlap 	(void) stmf_deregister_port_provider(iscsit_global.global_pp);
793a6d42e7dSPeter Dunlap 	stmf_free(iscsit_global.global_pp);
794a6d42e7dSPeter Dunlap 	iscsit_global.global_pp = NULL;
795a6d42e7dSPeter Dunlap 
796a6d42e7dSPeter Dunlap 	kmem_cache_destroy(iscsit_status_pdu_cache);
797a6d42e7dSPeter Dunlap 	iscsit_status_pdu_cache = NULL;
798a6d42e7dSPeter Dunlap 
799a6d42e7dSPeter Dunlap 	vmem_destroy(iscsit_global.global_tsih_pool);
800a6d42e7dSPeter Dunlap 	iscsit_global.global_tsih_pool = NULL;
801a6d42e7dSPeter Dunlap }
802a6d42e7dSPeter Dunlap 
803a6d42e7dSPeter Dunlap void
804a6d42e7dSPeter Dunlap iscsit_global_hold()
805a6d42e7dSPeter Dunlap {
806*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	/*
807*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * To take out a global hold, we must either own the global
808*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * state mutex or we must be running inside of an ioctl that
809*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * has set the global state to ISE_BUSY, ISE_DISABLING, or
810*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * ISE_ENABLING.  We don't track the "owner" for these flags,
811*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * so just checking if they are set is enough for now.
812*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 */
813*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	ASSERT((iscsit_global.global_svc_state == ISE_ENABLING) ||
814*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (iscsit_global.global_svc_state == ISE_DISABLING) ||
815*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    (iscsit_global.global_svc_state == ISE_BUSY) ||
816*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    MUTEX_HELD(&iscsit_global.global_state_mutex));
817*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
818a6d42e7dSPeter Dunlap 	idm_refcnt_hold(&iscsit_global.global_refcnt);
819a6d42e7dSPeter Dunlap }
820a6d42e7dSPeter Dunlap 
821a6d42e7dSPeter Dunlap void
822a6d42e7dSPeter Dunlap iscsit_global_rele()
823a6d42e7dSPeter Dunlap {
824a6d42e7dSPeter Dunlap 	idm_refcnt_rele(&iscsit_global.global_refcnt);
825a6d42e7dSPeter Dunlap }
826a6d42e7dSPeter Dunlap 
827a6d42e7dSPeter Dunlap void
828a6d42e7dSPeter Dunlap iscsit_global_wait_ref()
829a6d42e7dSPeter Dunlap {
830a6d42e7dSPeter Dunlap 	idm_refcnt_wait_ref(&iscsit_global.global_refcnt);
831a6d42e7dSPeter Dunlap }
832a6d42e7dSPeter Dunlap 
833a6d42e7dSPeter Dunlap /*
834a6d42e7dSPeter Dunlap  * IDM callbacks
835a6d42e7dSPeter Dunlap  */
836a6d42e7dSPeter Dunlap 
837a6d42e7dSPeter Dunlap /*ARGSUSED*/
838a6d42e7dSPeter Dunlap void
839a6d42e7dSPeter Dunlap iscsit_rx_pdu(idm_conn_t *ic, idm_pdu_t *rx_pdu)
840a6d42e7dSPeter Dunlap {
841a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
842a6d42e7dSPeter Dunlap 	switch (IDM_PDU_OPCODE(rx_pdu)) {
843a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_CMD:
844a6d42e7dSPeter Dunlap 		ASSERT(0); /* Shouldn't happen */
845a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
846a6d42e7dSPeter Dunlap 		break;
847a6d42e7dSPeter Dunlap 	case ISCSI_OP_SNACK_CMD:
848a6d42e7dSPeter Dunlap 		/*
849a6d42e7dSPeter Dunlap 		 * We'll need to handle this when we support ERL1/2.  For
850a6d42e7dSPeter Dunlap 		 * now we treat it as a protocol error.
851a6d42e7dSPeter Dunlap 		 */
852a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
853a6d42e7dSPeter Dunlap 		idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL);
854a6d42e7dSPeter Dunlap 		break;
855a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_TASK_MGT_MSG:
856a6d42e7dSPeter Dunlap 		iscsit_set_cmdsn(ict, rx_pdu);
857a6d42e7dSPeter Dunlap 		iscsit_op_scsi_task_mgmt(ict, rx_pdu);
858a6d42e7dSPeter Dunlap 		break;
859a6d42e7dSPeter Dunlap 	case ISCSI_OP_NOOP_OUT:
860a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGIN_CMD:
861a6d42e7dSPeter Dunlap 	case ISCSI_OP_TEXT_CMD:
862a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGOUT_CMD:
863a6d42e7dSPeter Dunlap 		/*
864a6d42e7dSPeter Dunlap 		 * If/when we switch to userland processing these PDU's
865a6d42e7dSPeter Dunlap 		 * will be handled by iscsitd.
866a6d42e7dSPeter Dunlap 		 */
867a6d42e7dSPeter Dunlap 		iscsit_deferred_dispatch(rx_pdu);
868a6d42e7dSPeter Dunlap 		break;
869a6d42e7dSPeter Dunlap 	default:
870a6d42e7dSPeter Dunlap 		/* Protocol error */
871a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
872a6d42e7dSPeter Dunlap 		idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL);
873a6d42e7dSPeter Dunlap 		break;
874a6d42e7dSPeter Dunlap 	}
875a6d42e7dSPeter Dunlap }
876a6d42e7dSPeter Dunlap 
877a6d42e7dSPeter Dunlap /*ARGSUSED*/
878a6d42e7dSPeter Dunlap void
879a6d42e7dSPeter Dunlap iscsit_rx_pdu_error(idm_conn_t *ic, idm_pdu_t *rx_pdu, idm_status_t status)
880a6d42e7dSPeter Dunlap {
881a6d42e7dSPeter Dunlap 	idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
882a6d42e7dSPeter Dunlap }
883a6d42e7dSPeter Dunlap 
884a6d42e7dSPeter Dunlap void
885a6d42e7dSPeter Dunlap iscsit_task_aborted(idm_task_t *idt, idm_status_t status)
886a6d42e7dSPeter Dunlap {
887a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = idt->idt_private;
888a6d42e7dSPeter Dunlap 
889a6d42e7dSPeter Dunlap 	switch (status) {
890a6d42e7dSPeter Dunlap 	case IDM_STATUS_SUSPENDED:
891a6d42e7dSPeter Dunlap 		break;
892a6d42e7dSPeter Dunlap 	case IDM_STATUS_ABORTED:
893a6d42e7dSPeter Dunlap 		mutex_enter(&itask->it_mutex);
894a6d42e7dSPeter Dunlap 		itask->it_aborted = B_TRUE;
895bf604c64SPeter Dunlap 		/*
896bf604c64SPeter Dunlap 		 * We rely on the fact that STMF tracks outstanding
897bf604c64SPeter Dunlap 		 * buffer transfers and will free all of our buffers
898bf604c64SPeter Dunlap 		 * before freeing the task so we don't need to
899bf604c64SPeter Dunlap 		 * explicitly free the buffers from iscsit/idm
900bf604c64SPeter Dunlap 		 */
901a6d42e7dSPeter Dunlap 		if (itask->it_stmf_abort) {
902a6d42e7dSPeter Dunlap 			mutex_exit(&itask->it_mutex);
90372cf3143Speter dunlap 			/*
90472cf3143Speter dunlap 			 * Task is no longer active
90572cf3143Speter dunlap 			 */
90672cf3143Speter dunlap 			iscsit_task_done(itask);
90772cf3143Speter dunlap 
908a6d42e7dSPeter Dunlap 			/*
909bf604c64SPeter Dunlap 			 * STMF has already asked for this task to be aborted
910bf604c64SPeter Dunlap 			 *
911a6d42e7dSPeter Dunlap 			 * STMF specification is wrong... says to return
912a6d42e7dSPeter Dunlap 			 * STMF_ABORTED, the code actually looks for
913a6d42e7dSPeter Dunlap 			 * STMF_ABORT_SUCCESS.
914a6d42e7dSPeter Dunlap 			 */
915a6d42e7dSPeter Dunlap 			stmf_task_lport_aborted(itask->it_stmf_task,
916a6d42e7dSPeter Dunlap 			    STMF_ABORT_SUCCESS, STMF_IOF_LPORT_DONE);
917a6d42e7dSPeter Dunlap 			return;
918a6d42e7dSPeter Dunlap 		} else {
919a6d42e7dSPeter Dunlap 			mutex_exit(&itask->it_mutex);
920a6d42e7dSPeter Dunlap 			/*
921bf604c64SPeter Dunlap 			 * Tell STMF to stop processing the task.
922a6d42e7dSPeter Dunlap 			 */
923a6d42e7dSPeter Dunlap 			stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task,
924a6d42e7dSPeter Dunlap 			    STMF_ABORTED, NULL);
925a6d42e7dSPeter Dunlap 			return;
926a6d42e7dSPeter Dunlap 		}
927a6d42e7dSPeter Dunlap 		/*NOTREACHED*/
928a6d42e7dSPeter Dunlap 	default:
929a6d42e7dSPeter Dunlap 		ASSERT(0);
930a6d42e7dSPeter Dunlap 	}
931a6d42e7dSPeter Dunlap }
932a6d42e7dSPeter Dunlap 
933a6d42e7dSPeter Dunlap /*ARGSUSED*/
934a6d42e7dSPeter Dunlap idm_status_t
935a6d42e7dSPeter Dunlap iscsit_client_notify(idm_conn_t *ic, idm_client_notify_t icn,
936a6d42e7dSPeter Dunlap     uintptr_t data)
937a6d42e7dSPeter Dunlap {
938a6d42e7dSPeter Dunlap 	idm_status_t rc = IDM_STATUS_SUCCESS;
939a6d42e7dSPeter Dunlap 
940a6d42e7dSPeter Dunlap 	/*
941a6d42e7dSPeter Dunlap 	 * IDM client notifications will never occur at interrupt level
942a6d42e7dSPeter Dunlap 	 * since they are generated from the connection state machine which
943a6d42e7dSPeter Dunlap 	 * running on taskq threads.
944a6d42e7dSPeter Dunlap 	 *
945a6d42e7dSPeter Dunlap 	 */
946a6d42e7dSPeter Dunlap 	switch (icn) {
947a6d42e7dSPeter Dunlap 	case CN_CONNECT_ACCEPT:
948a6d42e7dSPeter Dunlap 		rc = iscsit_conn_accept(ic); /* No data */
949a6d42e7dSPeter Dunlap 		break;
950a6d42e7dSPeter Dunlap 	case CN_FFP_ENABLED:
951a6d42e7dSPeter Dunlap 		rc = iscsit_ffp_enabled(ic); /* No data */
952a6d42e7dSPeter Dunlap 		break;
953a6d42e7dSPeter Dunlap 	case CN_FFP_DISABLED:
954a6d42e7dSPeter Dunlap 		/*
955a6d42e7dSPeter Dunlap 		 * Data indicates whether this was the result of an
956a6d42e7dSPeter Dunlap 		 * explicit logout request.
957a6d42e7dSPeter Dunlap 		 */
958a6d42e7dSPeter Dunlap 		rc = iscsit_ffp_disabled(ic, (idm_ffp_disable_t)data);
959a6d42e7dSPeter Dunlap 		break;
960a6d42e7dSPeter Dunlap 	case CN_CONNECT_LOST:
961a6d42e7dSPeter Dunlap 		rc = iscsit_conn_lost(ic);
962a6d42e7dSPeter Dunlap 		break;
963a6d42e7dSPeter Dunlap 	case CN_CONNECT_DESTROY:
964a6d42e7dSPeter Dunlap 		rc = iscsit_conn_destroy(ic);
965a6d42e7dSPeter Dunlap 		break;
966a6d42e7dSPeter Dunlap 	case CN_LOGIN_FAIL:
967a6d42e7dSPeter Dunlap 		/*
968a6d42e7dSPeter Dunlap 		 * Force the login state machine to completion
969a6d42e7dSPeter Dunlap 		 */
970a6d42e7dSPeter Dunlap 		rc = iscsit_login_fail(ic);
971a6d42e7dSPeter Dunlap 		break;
972a6d42e7dSPeter Dunlap 	default:
973a6d42e7dSPeter Dunlap 		rc = IDM_STATUS_REJECT;
974a6d42e7dSPeter Dunlap 		break;
975a6d42e7dSPeter Dunlap 	}
976a6d42e7dSPeter Dunlap 
977a6d42e7dSPeter Dunlap 	return (rc);
978a6d42e7dSPeter Dunlap }
979a6d42e7dSPeter Dunlap 
98060220f10SPriya Krishnan /*
98160220f10SPriya Krishnan  * iscsit_update_statsn is invoked for all the PDUs which have the StatSN
98260220f10SPriya Krishnan  * field in the header. The StatSN is incremented if the IDM_PDU_ADVANCE_STATSN
98360220f10SPriya Krishnan  * flag is set in the pdu flags field. The StatSN is connection-wide and is
98460220f10SPriya Krishnan  * protected by the mutex ict_statsn_mutex. For Data-In PDUs, if the flag
98560220f10SPriya Krishnan  * IDM_TASK_PHASECOLLAPSE_REQ is set, the status (phase-collapse) is also filled
98660220f10SPriya Krishnan  */
98760220f10SPriya Krishnan void
98860220f10SPriya Krishnan iscsit_update_statsn(idm_task_t *idm_task, idm_pdu_t *pdu)
98960220f10SPriya Krishnan {
99060220f10SPriya Krishnan 	iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
99160220f10SPriya Krishnan 	iscsit_conn_t *ict = (iscsit_conn_t *)pdu->isp_ic->ic_handle;
99260220f10SPriya Krishnan 	iscsit_task_t *itask = NULL;
99360220f10SPriya Krishnan 	scsi_task_t *task = NULL;
99460220f10SPriya Krishnan 
99560220f10SPriya Krishnan 	mutex_enter(&ict->ict_statsn_mutex);
99660220f10SPriya Krishnan 	rsp->statsn = htonl(ict->ict_statsn);
99760220f10SPriya Krishnan 	if (pdu->isp_flags & IDM_PDU_ADVANCE_STATSN)
99860220f10SPriya Krishnan 		ict->ict_statsn++;
99960220f10SPriya Krishnan 	mutex_exit(&ict->ict_statsn_mutex);
100060220f10SPriya Krishnan 
100160220f10SPriya Krishnan 	/*
100260220f10SPriya Krishnan 	 * The last SCSI Data PDU passed for a command may also contain the
100360220f10SPriya Krishnan 	 * status if the status indicates termination with no expections, i.e.
100460220f10SPriya Krishnan 	 * no sense data or response involved. If the command completes with
100560220f10SPriya Krishnan 	 * an error, then the response and sense data will be sent in a
100660220f10SPriya Krishnan 	 * separate iSCSI Response PDU.
100760220f10SPriya Krishnan 	 */
100860220f10SPriya Krishnan 	if ((idm_task) && (idm_task->idt_flags & IDM_TASK_PHASECOLLAPSE_REQ)) {
100960220f10SPriya Krishnan 		itask = idm_task->idt_private;
101060220f10SPriya Krishnan 		task = itask->it_stmf_task;
101160220f10SPriya Krishnan 
101260220f10SPriya Krishnan 		rsp->cmd_status = task->task_scsi_status;
101360220f10SPriya Krishnan 		rsp->flags	|= ISCSI_FLAG_DATA_STATUS;
101460220f10SPriya Krishnan 		if (task->task_status_ctrl & TASK_SCTRL_OVER) {
101560220f10SPriya Krishnan 			rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW;
101660220f10SPriya Krishnan 		} else if (task->task_status_ctrl & TASK_SCTRL_UNDER) {
101760220f10SPriya Krishnan 			rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
101860220f10SPriya Krishnan 		}
101960220f10SPriya Krishnan 		rsp->residual_count = htonl(task->task_resid);
102060220f10SPriya Krishnan 	}
102160220f10SPriya Krishnan }
1022a6d42e7dSPeter Dunlap 
1023a6d42e7dSPeter Dunlap void
1024a6d42e7dSPeter Dunlap iscsit_build_hdr(idm_task_t *idm_task, idm_pdu_t *pdu, uint8_t opcode)
1025a6d42e7dSPeter Dunlap {
1026a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = idm_task->idt_private;
1027a6d42e7dSPeter Dunlap 	iscsi_data_rsp_hdr_t *dh = (iscsi_data_rsp_hdr_t *)pdu->isp_hdr;
1028a6d42e7dSPeter Dunlap 
1029a6d42e7dSPeter Dunlap 	/*
1030a6d42e7dSPeter Dunlap 	 * We acquired iscsit_sess_t.ist_sn_rwlock in iscsit_xfer_scsi_data
1031a6d42e7dSPeter Dunlap 	 * in reader mode so we expect to be locked here
1032a6d42e7dSPeter Dunlap 	 */
1033a6d42e7dSPeter Dunlap 
1034a6d42e7dSPeter Dunlap 	/*
1035a6d42e7dSPeter Dunlap 	 * Lun is only required if the opcode == ISCSI_OP_SCSI_DATA_RSP
1036a6d42e7dSPeter Dunlap 	 * and the 'A' bit is to be set
1037a6d42e7dSPeter Dunlap 	 */
1038a6d42e7dSPeter Dunlap 	dh->opcode = opcode;
1039a6d42e7dSPeter Dunlap 	dh->itt = itask->it_itt;
1040a6d42e7dSPeter Dunlap 	dh->ttt = itask->it_ttt;
10411050fd6dSJames Moore 	/* Maintain current statsn for RTT responses */
10421050fd6dSJames Moore 	dh->statsn = (opcode == ISCSI_OP_RTT_RSP) ?
10431050fd6dSJames Moore 	    htonl(itask->it_ict->ict_statsn) : 0;
104460220f10SPriya Krishnan 
1045a6d42e7dSPeter Dunlap 	dh->expcmdsn = htonl(itask->it_ict->ict_sess->ist_expcmdsn);
1046a6d42e7dSPeter Dunlap 	dh->maxcmdsn = htonl(itask->it_ict->ict_sess->ist_maxcmdsn);
1047a6d42e7dSPeter Dunlap 
1048a6d42e7dSPeter Dunlap 	/*
1049a6d42e7dSPeter Dunlap 	 * IDM must set:
1050a6d42e7dSPeter Dunlap 	 *
1051a6d42e7dSPeter Dunlap 	 * data.flags and rtt.flags
1052a6d42e7dSPeter Dunlap 	 * data.dlength
1053a6d42e7dSPeter Dunlap 	 * data.datasn
1054a6d42e7dSPeter Dunlap 	 * data.offset
105560220f10SPriya Krishnan 	 * statsn, residual_count and cmd_status (for phase collapse)
1056a6d42e7dSPeter Dunlap 	 * rtt.rttsn
1057a6d42e7dSPeter Dunlap 	 * rtt.data_offset
1058a6d42e7dSPeter Dunlap 	 * rtt.data_length
1059a6d42e7dSPeter Dunlap 	 */
1060a6d42e7dSPeter Dunlap }
1061a6d42e7dSPeter Dunlap 
106272cf3143Speter dunlap void
106372cf3143Speter dunlap iscsit_keepalive(idm_conn_t *ic)
106472cf3143Speter dunlap {
106572cf3143Speter dunlap 	idm_pdu_t		*nop_in_pdu;
106672cf3143Speter dunlap 	iscsi_nop_in_hdr_t	*nop_in;
106772cf3143Speter dunlap 	iscsit_conn_t		*ict = ic->ic_handle;
106872cf3143Speter dunlap 
106972cf3143Speter dunlap 	/*
107072cf3143Speter dunlap 	 * IDM noticed the connection has been idle for too long so it's
107172cf3143Speter dunlap 	 * time to provoke some activity.  Build and transmit an iSCSI
107272cf3143Speter dunlap 	 * nop-in PDU -- when the initiator responds it will be counted
107372cf3143Speter dunlap 	 * as "activity" and keep the connection alive.
107472cf3143Speter dunlap 	 *
107572cf3143Speter dunlap 	 * We don't actually care about the response here at the iscsit level
107672cf3143Speter dunlap 	 * so we will just throw it away without looking at it when it arrives.
107772cf3143Speter dunlap 	 */
107872cf3143Speter dunlap 	nop_in_pdu = idm_pdu_alloc(sizeof (*nop_in), 0);
107972cf3143Speter dunlap 	idm_pdu_init(nop_in_pdu, ic, NULL, NULL);
108072cf3143Speter dunlap 	nop_in = (iscsi_nop_in_hdr_t *)nop_in_pdu->isp_hdr;
108172cf3143Speter dunlap 	bzero(nop_in, sizeof (*nop_in));
108272cf3143Speter dunlap 	nop_in->opcode = ISCSI_OP_NOOP_IN;
108372cf3143Speter dunlap 	nop_in->flags = ISCSI_FLAG_FINAL;
108472cf3143Speter dunlap 	nop_in->itt = ISCSI_RSVD_TASK_TAG;
108560220f10SPriya Krishnan 	/*
108660220f10SPriya Krishnan 	 * When the target sends a NOP-In as a Ping, the target transfer tag
108760220f10SPriya Krishnan 	 * is set to a valid (not reserved) value and the initiator task tag
108860220f10SPriya Krishnan 	 * is set to ISCSI_RSVD_TASK_TAG (0xffffffff). In this case the StatSN
108960220f10SPriya Krishnan 	 * will always contain the next sequence number but the StatSN for the
109060220f10SPriya Krishnan 	 * connection is not advanced after this PDU is sent.
109160220f10SPriya Krishnan 	 */
109260220f10SPriya Krishnan 	nop_in_pdu->isp_flags |= IDM_PDU_SET_STATSN;
109372cf3143Speter dunlap 	/*
109472cf3143Speter dunlap 	 * This works because we don't currently allocate ttt's anywhere else
109572cf3143Speter dunlap 	 * in iscsit so as long as we stay out of IDM's range we are safe.
109672cf3143Speter dunlap 	 * If we need to allocate ttt's for other PDU's in the future this will
109772cf3143Speter dunlap 	 * need to be improved.
109872cf3143Speter dunlap 	 */
109972cf3143Speter dunlap 	mutex_enter(&ict->ict_mutex);
110072cf3143Speter dunlap 	nop_in->ttt = ict->ict_keepalive_ttt;
110172cf3143Speter dunlap 	ict->ict_keepalive_ttt++;
110272cf3143Speter dunlap 	if (ict->ict_keepalive_ttt == ISCSI_RSVD_TASK_TAG)
110372cf3143Speter dunlap 		ict->ict_keepalive_ttt = IDM_TASKIDS_MAX;
110472cf3143Speter dunlap 	mutex_exit(&ict->ict_mutex);
110572cf3143Speter dunlap 
110672cf3143Speter dunlap 	iscsit_pdu_tx(nop_in_pdu);
110772cf3143Speter dunlap }
110872cf3143Speter dunlap 
1109a6d42e7dSPeter Dunlap static idm_status_t
1110a6d42e7dSPeter Dunlap iscsit_conn_accept(idm_conn_t *ic)
1111a6d42e7dSPeter Dunlap {
1112a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict;
1113a6d42e7dSPeter Dunlap 
111430e7468fSPeter Dunlap 	/*
111530e7468fSPeter Dunlap 	 * We need to get a global hold here to ensure that the service
111630e7468fSPeter Dunlap 	 * doesn't get shutdown prior to establishing a session. This
111730e7468fSPeter Dunlap 	 * gets released in iscsit_conn_destroy().
111830e7468fSPeter Dunlap 	 */
1119*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_enter(&iscsit_global.global_state_mutex);
1120e42a0851Speter dunlap 	if (iscsit_global.global_svc_state != ISE_ENABLED) {
1121*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
1122e42a0851Speter dunlap 		return (IDM_STATUS_FAIL);
1123e42a0851Speter dunlap 	}
112430e7468fSPeter Dunlap 	iscsit_global_hold();
1125*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_exit(&iscsit_global.global_state_mutex);
112630e7468fSPeter Dunlap 
1127a6d42e7dSPeter Dunlap 	/*
1128a6d42e7dSPeter Dunlap 	 * Allocate an associated iscsit structure to represent this
1129a6d42e7dSPeter Dunlap 	 * connection.  We shouldn't really create a session until we
1130a6d42e7dSPeter Dunlap 	 * get the first login PDU.
1131a6d42e7dSPeter Dunlap 	 */
1132a6d42e7dSPeter Dunlap 	ict = kmem_zalloc(sizeof (*ict), KM_SLEEP);
1133a6d42e7dSPeter Dunlap 
1134a6d42e7dSPeter Dunlap 	ict->ict_ic = ic;
1135a6d42e7dSPeter Dunlap 	ict->ict_statsn = 1;
113672cf3143Speter dunlap 	ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; /* Avoid IDM TT range */
1137a6d42e7dSPeter Dunlap 	ic->ic_handle = ict;
1138a6d42e7dSPeter Dunlap 	mutex_init(&ict->ict_mutex, NULL, MUTEX_DRIVER, NULL);
113960220f10SPriya Krishnan 	mutex_init(&ict->ict_statsn_mutex, NULL, MUTEX_DRIVER, NULL);
1140a6d42e7dSPeter Dunlap 	idm_refcnt_init(&ict->ict_refcnt, ict);
1141a6d42e7dSPeter Dunlap 
1142a6d42e7dSPeter Dunlap 	/*
1143a6d42e7dSPeter Dunlap 	 * Initialize login state machine
1144a6d42e7dSPeter Dunlap 	 */
1145a6d42e7dSPeter Dunlap 	if (iscsit_login_sm_init(ict) != IDM_STATUS_SUCCESS) {
1146e42a0851Speter dunlap 		iscsit_global_rele();
11474142b486SJames Moore 		/*
11484142b486SJames Moore 		 * Cleanup the ict after idm notifies us about this failure
11494142b486SJames Moore 		 */
1150a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
1151a6d42e7dSPeter Dunlap 	}
1152a6d42e7dSPeter Dunlap 
1153a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1154a6d42e7dSPeter Dunlap }
1155a6d42e7dSPeter Dunlap 
1156a6d42e7dSPeter Dunlap idm_status_t
1157a6d42e7dSPeter Dunlap iscsit_conn_reinstate(iscsit_conn_t *reinstate_ict, iscsit_conn_t *new_ict)
1158a6d42e7dSPeter Dunlap {
1159a6d42e7dSPeter Dunlap 	idm_status_t	result;
1160a6d42e7dSPeter Dunlap 
1161a6d42e7dSPeter Dunlap 	/*
1162a6d42e7dSPeter Dunlap 	 * Note in new connection state that this connection is
1163a6d42e7dSPeter Dunlap 	 * reinstating an existing connection.
1164a6d42e7dSPeter Dunlap 	 */
1165a6d42e7dSPeter Dunlap 	new_ict->ict_reinstating = B_TRUE;
1166a6d42e7dSPeter Dunlap 	new_ict->ict_reinstate_conn = reinstate_ict;
1167a6d42e7dSPeter Dunlap 	new_ict->ict_statsn = reinstate_ict->ict_statsn;
1168a6d42e7dSPeter Dunlap 
1169a6d42e7dSPeter Dunlap 	/*
1170a6d42e7dSPeter Dunlap 	 * Now generate connection state machine event to existing connection
1171a6d42e7dSPeter Dunlap 	 * so that it starts the cleanup process.
1172a6d42e7dSPeter Dunlap 	 */
1173a6d42e7dSPeter Dunlap 	result = idm_conn_reinstate_event(reinstate_ict->ict_ic,
1174a6d42e7dSPeter Dunlap 	    new_ict->ict_ic);
1175a6d42e7dSPeter Dunlap 
1176a6d42e7dSPeter Dunlap 	return (result);
1177a6d42e7dSPeter Dunlap }
1178a6d42e7dSPeter Dunlap 
1179a6d42e7dSPeter Dunlap void
1180a6d42e7dSPeter Dunlap iscsit_conn_hold(iscsit_conn_t *ict)
1181a6d42e7dSPeter Dunlap {
1182a6d42e7dSPeter Dunlap 	idm_refcnt_hold(&ict->ict_refcnt);
1183a6d42e7dSPeter Dunlap }
1184a6d42e7dSPeter Dunlap 
1185a6d42e7dSPeter Dunlap void
1186a6d42e7dSPeter Dunlap iscsit_conn_rele(iscsit_conn_t *ict)
1187a6d42e7dSPeter Dunlap {
1188a6d42e7dSPeter Dunlap 	idm_refcnt_rele(&ict->ict_refcnt);
1189a6d42e7dSPeter Dunlap }
1190a6d42e7dSPeter Dunlap 
1191a6d42e7dSPeter Dunlap void
1192a6d42e7dSPeter Dunlap iscsit_conn_dispatch_hold(iscsit_conn_t *ict)
1193a6d42e7dSPeter Dunlap {
1194a6d42e7dSPeter Dunlap 	idm_refcnt_hold(&ict->ict_dispatch_refcnt);
1195a6d42e7dSPeter Dunlap }
1196a6d42e7dSPeter Dunlap 
1197a6d42e7dSPeter Dunlap void
1198a6d42e7dSPeter Dunlap iscsit_conn_dispatch_rele(iscsit_conn_t *ict)
1199a6d42e7dSPeter Dunlap {
1200a6d42e7dSPeter Dunlap 	idm_refcnt_rele(&ict->ict_dispatch_refcnt);
1201a6d42e7dSPeter Dunlap }
1202a6d42e7dSPeter Dunlap 
1203a6d42e7dSPeter Dunlap static idm_status_t
1204a6d42e7dSPeter Dunlap iscsit_login_fail(idm_conn_t *ic)
1205a6d42e7dSPeter Dunlap {
1206a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
1207a6d42e7dSPeter Dunlap 
1208a6d42e7dSPeter Dunlap 	/* Generate login state machine event */
1209a6d42e7dSPeter Dunlap 	iscsit_login_sm_event(ict, ILE_LOGIN_CONN_ERROR, NULL);
1210a6d42e7dSPeter Dunlap 
1211a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1212a6d42e7dSPeter Dunlap }
1213a6d42e7dSPeter Dunlap 
1214a6d42e7dSPeter Dunlap static idm_status_t
1215a6d42e7dSPeter Dunlap iscsit_ffp_enabled(idm_conn_t *ic)
1216a6d42e7dSPeter Dunlap {
1217a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
1218a6d42e7dSPeter Dunlap 
1219a6d42e7dSPeter Dunlap 	/* Generate session state machine event */
1220a6d42e7dSPeter Dunlap 	iscsit_sess_sm_event(ict->ict_sess, SE_CONN_LOGGED_IN, ict);
1221a6d42e7dSPeter Dunlap 
1222a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1223a6d42e7dSPeter Dunlap }
1224a6d42e7dSPeter Dunlap 
1225a6d42e7dSPeter Dunlap static idm_status_t
1226a6d42e7dSPeter Dunlap iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class)
1227a6d42e7dSPeter Dunlap {
1228a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
1229a6d42e7dSPeter Dunlap 
1230a6d42e7dSPeter Dunlap 	/* Generate session state machine event */
1231a6d42e7dSPeter Dunlap 	switch (disable_class) {
1232a6d42e7dSPeter Dunlap 	case FD_CONN_FAIL:
1233a6d42e7dSPeter Dunlap 		iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_FAIL, ict);
1234a6d42e7dSPeter Dunlap 		break;
1235a6d42e7dSPeter Dunlap 	case FD_CONN_LOGOUT:
1236a6d42e7dSPeter Dunlap 		iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_DISABLE, ict);
1237a6d42e7dSPeter Dunlap 		break;
1238a6d42e7dSPeter Dunlap 	case FD_SESS_LOGOUT:
1239a6d42e7dSPeter Dunlap 		iscsit_sess_sm_event(ict->ict_sess, SE_SESSION_CLOSE, ict);
1240a6d42e7dSPeter Dunlap 		break;
1241a6d42e7dSPeter Dunlap 	default:
1242a6d42e7dSPeter Dunlap 		ASSERT(0);
1243a6d42e7dSPeter Dunlap 	}
1244a6d42e7dSPeter Dunlap 
1245a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1246a6d42e7dSPeter Dunlap }
1247a6d42e7dSPeter Dunlap 
1248a6d42e7dSPeter Dunlap static idm_status_t
1249a6d42e7dSPeter Dunlap iscsit_conn_lost(idm_conn_t *ic)
1250a6d42e7dSPeter Dunlap {
1251a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
1252a6d42e7dSPeter Dunlap 
1253a6d42e7dSPeter Dunlap 	mutex_enter(&ict->ict_mutex);
1254a6d42e7dSPeter Dunlap 	ict->ict_lost = B_TRUE;
1255a6d42e7dSPeter Dunlap 	mutex_exit(&ict->ict_mutex);
1256a6d42e7dSPeter Dunlap 
1257a6d42e7dSPeter Dunlap 	/*
1258a6d42e7dSPeter Dunlap 	 * Make sure there aren't any PDU's transitioning from the receive
1259a6d42e7dSPeter Dunlap 	 * handler to the dispatch taskq.
1260a6d42e7dSPeter Dunlap 	 */
1261a6d42e7dSPeter Dunlap 	idm_refcnt_wait_ref(&ict->ict_dispatch_refcnt);
1262a6d42e7dSPeter Dunlap 
1263a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1264a6d42e7dSPeter Dunlap }
1265a6d42e7dSPeter Dunlap 
1266a6d42e7dSPeter Dunlap static idm_status_t
1267a6d42e7dSPeter Dunlap iscsit_conn_destroy(idm_conn_t *ic)
1268a6d42e7dSPeter Dunlap {
1269a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
1270a6d42e7dSPeter Dunlap 
1271a6d42e7dSPeter Dunlap 	mutex_enter(&ict->ict_mutex);
1272a6d42e7dSPeter Dunlap 	ict->ict_destroyed = B_TRUE;
1273a6d42e7dSPeter Dunlap 	mutex_exit(&ict->ict_mutex);
1274a6d42e7dSPeter Dunlap 
1275a6d42e7dSPeter Dunlap 	/* Generate session state machine event */
1276a6d42e7dSPeter Dunlap 	if (ict->ict_sess != NULL) {
1277a6d42e7dSPeter Dunlap 		/*
1278a6d42e7dSPeter Dunlap 		 * Session state machine will call iscsit_conn_destroy_done()
1279a6d42e7dSPeter Dunlap 		 * when it has removed references to this connection.
1280a6d42e7dSPeter Dunlap 		 */
1281a6d42e7dSPeter Dunlap 		iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FAIL, ict);
1282a6d42e7dSPeter Dunlap 	}
1283a6d42e7dSPeter Dunlap 
1284a6d42e7dSPeter Dunlap 	ict->ict_ic = NULL;
1285a6d42e7dSPeter Dunlap 
1286a6d42e7dSPeter Dunlap 	idm_refcnt_wait_ref(&ict->ict_refcnt);
1287a6d42e7dSPeter Dunlap 
12884142b486SJames Moore 	/* Reap the login state machine */
12894142b486SJames Moore 	iscsit_login_sm_fini(ict);
12904142b486SJames Moore 
12914142b486SJames Moore 	/* Clean up any text command remnants */
12924142b486SJames Moore 	iscsit_text_cmd_fini(ict);
12934142b486SJames Moore 
1294a6d42e7dSPeter Dunlap 	mutex_destroy(&ict->ict_mutex);
1295a6d42e7dSPeter Dunlap 	idm_refcnt_destroy(&ict->ict_refcnt);
1296a6d42e7dSPeter Dunlap 	kmem_free(ict, sizeof (*ict));
1297a6d42e7dSPeter Dunlap 
129830e7468fSPeter Dunlap 	iscsit_global_rele();
129930e7468fSPeter Dunlap 
1300a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1301a6d42e7dSPeter Dunlap }
1302a6d42e7dSPeter Dunlap 
1303a6d42e7dSPeter Dunlap /*
1304a6d42e7dSPeter Dunlap  * STMF-related functions
1305a6d42e7dSPeter Dunlap  *
1306a6d42e7dSPeter Dunlap  * iSCSI to STMF mapping
1307a6d42e7dSPeter Dunlap  *
1308a6d42e7dSPeter Dunlap  * Session == ?
1309a6d42e7dSPeter Dunlap  * Connection == bound to local port but not itself a local port
1310a6d42e7dSPeter Dunlap  * Target
1311a6d42e7dSPeter Dunlap  * Target portal (group?) == local port (really but we're not going to do this)
1312a6d42e7dSPeter Dunlap  *	iscsit needs to map connections to local ports (whatever we decide
1313a6d42e7dSPeter Dunlap  * 	they are)
1314a6d42e7dSPeter Dunlap  * Target == ?
1315a6d42e7dSPeter Dunlap  */
1316a6d42e7dSPeter Dunlap 
1317a6d42e7dSPeter Dunlap /*ARGSUSED*/
1318a6d42e7dSPeter Dunlap static stmf_data_buf_t *
1319a6d42e7dSPeter Dunlap iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize,
1320a6d42e7dSPeter Dunlap     uint32_t flags)
1321a6d42e7dSPeter Dunlap {
1322a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = task->task_port_private;
1323a6d42e7dSPeter Dunlap 	idm_buf_t *idm_buffer;
1324a6d42e7dSPeter Dunlap 	iscsit_buf_t	*ibuf;
1325a6d42e7dSPeter Dunlap 	stmf_data_buf_t *result;
132626ec4a22SPriya Krishnan 	uint32_t	bsize;
1327a6d42e7dSPeter Dunlap 
1328a6d42e7dSPeter Dunlap 	/*
132901c0a610SPriya Krishnan 	 * If the requested size is larger than MaxBurstLength and the
133001c0a610SPriya Krishnan 	 * given pminsize is also larger than MaxBurstLength, then the
133101c0a610SPriya Krishnan 	 * allocation fails (dbuf = NULL) and pminsize is modified to
133201c0a610SPriya Krishnan 	 * be equal to MaxBurstLength. stmf/sbd then should re-invoke
133301c0a610SPriya Krishnan 	 * this function with the corrected values for transfer.
1334a6d42e7dSPeter Dunlap 	 */
133526ec4a22SPriya Krishnan 	ASSERT(pminsize);
133601c0a610SPriya Krishnan 	if (size <= itask->it_ict->ict_op.op_max_burst_length) {
133701c0a610SPriya Krishnan 		bsize = size;
133801c0a610SPriya Krishnan 	} else if (*pminsize <= itask->it_ict->ict_op.op_max_burst_length) {
133901c0a610SPriya Krishnan 		bsize = itask->it_ict->ict_op.op_max_burst_length;
134001c0a610SPriya Krishnan 	} else {
1341a6d42e7dSPeter Dunlap 		*pminsize = itask->it_ict->ict_op.op_max_burst_length;
1342a6d42e7dSPeter Dunlap 		return (NULL);
1343a6d42e7dSPeter Dunlap 	}
1344a6d42e7dSPeter Dunlap 
1345a6d42e7dSPeter Dunlap 	/* Alloc buffer */
134626ec4a22SPriya Krishnan 	idm_buffer = idm_buf_alloc(itask->it_ict->ict_ic, NULL, bsize);
1347a6d42e7dSPeter Dunlap 	if (idm_buffer != NULL) {
1348a6d42e7dSPeter Dunlap 		result = stmf_alloc(STMF_STRUCT_DATA_BUF,
1349a6d42e7dSPeter Dunlap 		    sizeof (iscsit_buf_t), 0);
1350a6d42e7dSPeter Dunlap 		if (result != NULL) {
1351a6d42e7dSPeter Dunlap 			/* Fill in stmf_data_buf_t */
1352a6d42e7dSPeter Dunlap 			ibuf = result->db_port_private;
1353a6d42e7dSPeter Dunlap 			ibuf->ibuf_idm_buf = idm_buffer;
1354a6d42e7dSPeter Dunlap 			ibuf->ibuf_stmf_buf = result;
1355a6d42e7dSPeter Dunlap 			ibuf->ibuf_is_immed = B_FALSE;
1356a6d42e7dSPeter Dunlap 			result->db_flags = DB_DONT_CACHE;
135726ec4a22SPriya Krishnan 			result->db_buf_size = bsize;
135826ec4a22SPriya Krishnan 			result->db_data_size = bsize;
1359a6d42e7dSPeter Dunlap 			result->db_sglist_length = 1;
1360a6d42e7dSPeter Dunlap 			result->db_sglist[0].seg_addr = idm_buffer->idb_buf;
1361a6d42e7dSPeter Dunlap 			result->db_sglist[0].seg_length =
1362a6d42e7dSPeter Dunlap 			    idm_buffer->idb_buflen;
1363a6d42e7dSPeter Dunlap 			return (result);
1364a6d42e7dSPeter Dunlap 		}
1365a6d42e7dSPeter Dunlap 
1366a6d42e7dSPeter Dunlap 		/* Couldn't get the stmf_data_buf_t so free the buffer */
1367a6d42e7dSPeter Dunlap 		idm_buf_free(idm_buffer);
1368a6d42e7dSPeter Dunlap 	}
1369a6d42e7dSPeter Dunlap 
1370a6d42e7dSPeter Dunlap 	return (NULL);
1371a6d42e7dSPeter Dunlap }
1372a6d42e7dSPeter Dunlap 
1373a6d42e7dSPeter Dunlap /*ARGSUSED*/
1374a6d42e7dSPeter Dunlap static void
1375a6d42e7dSPeter Dunlap iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf)
1376a6d42e7dSPeter Dunlap {
1377a6d42e7dSPeter Dunlap 	iscsit_buf_t *ibuf = dbuf->db_port_private;
1378a6d42e7dSPeter Dunlap 
1379a6d42e7dSPeter Dunlap 	if (ibuf->ibuf_is_immed) {
1380a6d42e7dSPeter Dunlap 		/*
1381a6d42e7dSPeter Dunlap 		 * The iscsit_buf_t structure itself will be freed with its
1382a6d42e7dSPeter Dunlap 		 * associated task.  Here we just need to free the PDU that
1383a6d42e7dSPeter Dunlap 		 * held the immediate data.
1384a6d42e7dSPeter Dunlap 		 */
1385a6d42e7dSPeter Dunlap 		idm_pdu_complete(ibuf->ibuf_immed_data_pdu, IDM_STATUS_SUCCESS);
1386a6d42e7dSPeter Dunlap 		ibuf->ibuf_immed_data_pdu = 0;
1387a6d42e7dSPeter Dunlap 	} else {
1388a6d42e7dSPeter Dunlap 		idm_buf_free(ibuf->ibuf_idm_buf);
1389a6d42e7dSPeter Dunlap 		stmf_free(dbuf);
1390a6d42e7dSPeter Dunlap 	}
1391a6d42e7dSPeter Dunlap }
1392a6d42e7dSPeter Dunlap 
1393a6d42e7dSPeter Dunlap /*ARGSUSED*/
1394a6d42e7dSPeter Dunlap stmf_status_t
1395a6d42e7dSPeter Dunlap iscsit_xfer_scsi_data(scsi_task_t *task, stmf_data_buf_t *dbuf,
1396a6d42e7dSPeter Dunlap     uint32_t ioflags)
1397a6d42e7dSPeter Dunlap {
1398a6d42e7dSPeter Dunlap 	iscsit_task_t *iscsit_task = task->task_port_private;
139960220f10SPriya Krishnan 	iscsit_sess_t *ict_sess = iscsit_task->it_ict->ict_sess;
1400a6d42e7dSPeter Dunlap 	iscsit_buf_t *ibuf = dbuf->db_port_private;
1401a6d42e7dSPeter Dunlap 	int idm_rc;
1402a6d42e7dSPeter Dunlap 
1403bf604c64SPeter Dunlap 	/*
1404bf604c64SPeter Dunlap 	 * If we are aborting then we can ignore this request
1405bf604c64SPeter Dunlap 	 */
1406bf604c64SPeter Dunlap 	if (iscsit_task->it_stmf_abort) {
1407bf604c64SPeter Dunlap 		return (STMF_SUCCESS);
1408bf604c64SPeter Dunlap 	}
1409bf604c64SPeter Dunlap 
1410a6d42e7dSPeter Dunlap 	/*
1411a6d42e7dSPeter Dunlap 	 * If it's not immediate data then start the transfer
1412a6d42e7dSPeter Dunlap 	 */
1413a6d42e7dSPeter Dunlap 	ASSERT(ibuf->ibuf_is_immed == B_FALSE);
1414a6d42e7dSPeter Dunlap 	if (dbuf->db_flags & DB_DIRECTION_TO_RPORT) {
141560220f10SPriya Krishnan 		/*
141660220f10SPriya Krishnan 		 * The DB_SEND_STATUS_GOOD flag in the STMF data buffer allows
141760220f10SPriya Krishnan 		 * the port provider to phase-collapse, i.e. send the status
141860220f10SPriya Krishnan 		 * along with the final data PDU for the command. The port
141960220f10SPriya Krishnan 		 * provider passes this request to the transport layer by
142060220f10SPriya Krishnan 		 * setting a flag IDM_TASK_PHASECOLLAPSE_REQ in the task.
142160220f10SPriya Krishnan 		 */
142260220f10SPriya Krishnan 		if (dbuf->db_flags & DB_SEND_STATUS_GOOD)
142360220f10SPriya Krishnan 			iscsit_task->it_idm_task->idt_flags |=
142460220f10SPriya Krishnan 			    IDM_TASK_PHASECOLLAPSE_REQ;
1425a6d42e7dSPeter Dunlap 		/*
1426a6d42e7dSPeter Dunlap 		 * IDM will call iscsit_build_hdr so lock now to serialize
1427a6d42e7dSPeter Dunlap 		 * access to the SN values.  We need to lock here to enforce
1428a6d42e7dSPeter Dunlap 		 * lock ordering
1429a6d42e7dSPeter Dunlap 		 */
143060220f10SPriya Krishnan 		rw_enter(&ict_sess->ist_sn_rwlock, RW_READER);
1431a6d42e7dSPeter Dunlap 		idm_rc = idm_buf_tx_to_ini(iscsit_task->it_idm_task,
1432a6d42e7dSPeter Dunlap 		    ibuf->ibuf_idm_buf, dbuf->db_relative_offset,
1433a6d42e7dSPeter Dunlap 		    dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf);
143460220f10SPriya Krishnan 		rw_exit(&ict_sess->ist_sn_rwlock);
1435a6d42e7dSPeter Dunlap 
1436a6d42e7dSPeter Dunlap 		return (iscsit_idm_to_stmf(idm_rc));
1437a6d42e7dSPeter Dunlap 	} else if (dbuf->db_flags & DB_DIRECTION_FROM_RPORT) {
1438a6d42e7dSPeter Dunlap 		/* Grab the SN lock (see comment above) */
143960220f10SPriya Krishnan 		rw_enter(&ict_sess->ist_sn_rwlock, RW_READER);
1440a6d42e7dSPeter Dunlap 		idm_rc = idm_buf_rx_from_ini(iscsit_task->it_idm_task,
1441a6d42e7dSPeter Dunlap 		    ibuf->ibuf_idm_buf, dbuf->db_relative_offset,
1442a6d42e7dSPeter Dunlap 		    dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf);
144360220f10SPriya Krishnan 		rw_exit(&ict_sess->ist_sn_rwlock);
1444a6d42e7dSPeter Dunlap 
1445a6d42e7dSPeter Dunlap 		return (iscsit_idm_to_stmf(idm_rc));
1446a6d42e7dSPeter Dunlap 	}
1447a6d42e7dSPeter Dunlap 
1448a6d42e7dSPeter Dunlap 	/* What are we supposed to do if there is no direction? */
1449a6d42e7dSPeter Dunlap 	return (STMF_INVALID_ARG);
1450a6d42e7dSPeter Dunlap }
1451a6d42e7dSPeter Dunlap 
1452a6d42e7dSPeter Dunlap static void
1453a6d42e7dSPeter Dunlap iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status)
1454a6d42e7dSPeter Dunlap {
1455a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = idb->idb_task_binding->idt_private;
1456a6d42e7dSPeter Dunlap 	stmf_data_buf_t *dbuf = idb->idb_cb_arg;
1457a6d42e7dSPeter Dunlap 
1458a6d42e7dSPeter Dunlap 	dbuf->db_xfer_status = iscsit_idm_to_stmf(status);
1459a6d42e7dSPeter Dunlap 
1460bf604c64SPeter Dunlap 	/*
1461bf604c64SPeter Dunlap 	 * If the task has been aborted then we don't need to call STMF
1462bf604c64SPeter Dunlap 	 */
1463bf604c64SPeter Dunlap 	if (itask->it_stmf_abort) {
1464bf604c64SPeter Dunlap 		return;
1465bf604c64SPeter Dunlap 	}
1466bf604c64SPeter Dunlap 
1467a6d42e7dSPeter Dunlap 	/*
146860220f10SPriya Krishnan 	 * For ISCSI over TCP (not iSER), the last SCSI Data PDU passed
146960220f10SPriya Krishnan 	 * for a successful command contains the status as requested by
147060220f10SPriya Krishnan 	 * by COMSTAR (via the DB_SEND_STATUS_GOOD flag). But the iSER
147160220f10SPriya Krishnan 	 * transport does not support phase-collapse. So pretend we are
147260220f10SPriya Krishnan 	 * COMSTAR and send the status in a separate PDU now.
1473a6d42e7dSPeter Dunlap 	 */
147460220f10SPriya Krishnan 	if (idb->idb_task_binding->idt_flags & IDM_TASK_PHASECOLLAPSE_SUCCESS) {
147560220f10SPriya Krishnan 		/*
147660220f10SPriya Krishnan 		 * Mark task complete, remove task from the session task
147760220f10SPriya Krishnan 		 * list and notify COMSTAR that the status has been sent.
147860220f10SPriya Krishnan 		 */
147960220f10SPriya Krishnan 		iscsit_task_done(itask);
148060220f10SPriya Krishnan 		itask->it_idm_task->idt_state = TASK_COMPLETE;
148160220f10SPriya Krishnan 		stmf_send_status_done(itask->it_stmf_task,
148260220f10SPriya Krishnan 		    iscsit_idm_to_stmf(status), STMF_IOF_LPORT_DONE);
148360220f10SPriya Krishnan 	} else if ((dbuf->db_flags & DB_SEND_STATUS_GOOD) &&
1484a6d42e7dSPeter Dunlap 	    status == IDM_STATUS_SUCCESS) {
148560220f10SPriya Krishnan 
1486a6d42e7dSPeter Dunlap 		/*
148770a38f02SPriya Krishnan 		 * The iscsi target port provider - for iSER, emulates the
148870a38f02SPriya Krishnan 		 * DB_SEND_STATUS_GOOD optimization if requested by STMF;
148970a38f02SPriya Krishnan 		 * it sends the status in a separate PDU after the data
149070a38f02SPriya Krishnan 		 * transfer. In this case the port provider should first
149170a38f02SPriya Krishnan 		 * call stmf_data_xfer_done() to mark the transfer complete
149270a38f02SPriya Krishnan 		 * and then send the status. Although STMF will free the
149370a38f02SPriya Krishnan 		 * buffer at the time the task is freed, even if the transfer
149470a38f02SPriya Krishnan 		 * is not marked complete, this behavior makes statistics
149570a38f02SPriya Krishnan 		 * gathering and task state tracking more difficult than it
149670a38f02SPriya Krishnan 		 * needs to be.
1497a6d42e7dSPeter Dunlap 		 */
149870a38f02SPriya Krishnan 		stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0);
1499a6d42e7dSPeter Dunlap 		if (iscsit_send_scsi_status(itask->it_stmf_task, 0)
150063528ae4SJames Moore 		    != STMF_SUCCESS) {
150170a38f02SPriya Krishnan 			stmf_send_status_done(itask->it_stmf_task,
150270a38f02SPriya Krishnan 			    STMF_FAILURE, STMF_IOF_LPORT_DONE);
1503a6d42e7dSPeter Dunlap 		}
1504a6d42e7dSPeter Dunlap 	} else {
1505a6d42e7dSPeter Dunlap 		stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0);
150670a38f02SPriya Krishnan 		/* don't touch dbuf after stmf_data_xfer_done */
1507a6d42e7dSPeter Dunlap 	}
1508a6d42e7dSPeter Dunlap }
1509a6d42e7dSPeter Dunlap 
1510bf604c64SPeter Dunlap 
1511a6d42e7dSPeter Dunlap /*ARGSUSED*/
1512a6d42e7dSPeter Dunlap stmf_status_t
1513a6d42e7dSPeter Dunlap iscsit_send_scsi_status(scsi_task_t *task, uint32_t ioflags)
1514a6d42e7dSPeter Dunlap {
1515a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = task->task_port_private;
1516a6d42e7dSPeter Dunlap 	iscsi_scsi_rsp_hdr_t *rsp;
1517a6d42e7dSPeter Dunlap 	idm_pdu_t *pdu;
1518a6d42e7dSPeter Dunlap 	int resp_datalen;
1519a6d42e7dSPeter Dunlap 
1520a6d42e7dSPeter Dunlap 	/*
1521a6d42e7dSPeter Dunlap 	 * If this task is aborted then we don't need to respond.
1522a6d42e7dSPeter Dunlap 	 */
1523a6d42e7dSPeter Dunlap 	if (itask->it_stmf_abort) {
1524a6d42e7dSPeter Dunlap 		return (STMF_SUCCESS);
1525a6d42e7dSPeter Dunlap 	}
1526a6d42e7dSPeter Dunlap 
1527a6d42e7dSPeter Dunlap 	/*
1528a6d42e7dSPeter Dunlap 	 * If this is a task management status, handle it elsewhere.
1529a6d42e7dSPeter Dunlap 	 */
1530a6d42e7dSPeter Dunlap 	if (task->task_mgmt_function != TM_NONE) {
1531a6d42e7dSPeter Dunlap 		/*
1532a6d42e7dSPeter Dunlap 		 * Don't wait for the PDU completion to tell STMF
1533a6d42e7dSPeter Dunlap 		 * the task is done -- it doesn't really matter and
1534a6d42e7dSPeter Dunlap 		 * it makes life complicated if STMF later asks us to
1535a6d42e7dSPeter Dunlap 		 * abort the request and we don't know whether the
1536a6d42e7dSPeter Dunlap 		 * status has been sent or not.
1537a6d42e7dSPeter Dunlap 		 */
1538a6d42e7dSPeter Dunlap 		itask->it_tm_responded = B_TRUE;
1539a6d42e7dSPeter Dunlap 		iscsit_send_task_mgmt_resp(itask->it_tm_pdu,
1540a6d42e7dSPeter Dunlap 		    (task->task_completion_status == STMF_SUCCESS) ?
1541a6d42e7dSPeter Dunlap 		    SCSI_TCP_TM_RESP_COMPLETE : SCSI_TCP_TM_RESP_FUNC_NOT_SUPP);
1542a6d42e7dSPeter Dunlap 		stmf_send_status_done(task, STMF_SUCCESS,
1543a6d42e7dSPeter Dunlap 		    STMF_IOF_LPORT_DONE);
1544a6d42e7dSPeter Dunlap 		return (STMF_SUCCESS);
1545a6d42e7dSPeter Dunlap 	}
1546a6d42e7dSPeter Dunlap 
154772cf3143Speter dunlap 	/*
154872cf3143Speter dunlap 	 * Remove the task from the session task list
154972cf3143Speter dunlap 	 */
155072cf3143Speter dunlap 	iscsit_task_done(itask);
155172cf3143Speter dunlap 
155272cf3143Speter dunlap 	/*
155372cf3143Speter dunlap 	 * Send status
155472cf3143Speter dunlap 	 */
1555a6d42e7dSPeter Dunlap 	mutex_enter(&itask->it_idm_task->idt_mutex);
1556a6d42e7dSPeter Dunlap 	if ((itask->it_idm_task->idt_state == TASK_ACTIVE) &&
1557a6d42e7dSPeter Dunlap 	    (task->task_completion_status == STMF_SUCCESS) &&
1558a6d42e7dSPeter Dunlap 	    (task->task_sense_length == 0) &&
1559a6d42e7dSPeter Dunlap 	    (task->task_resid == 0)) {
1560a6d42e7dSPeter Dunlap 		itask->it_idm_task->idt_state = TASK_COMPLETE;
1561a6d42e7dSPeter Dunlap 		/* PDU callback releases task hold */
1562a6d42e7dSPeter Dunlap 		idm_task_hold(itask->it_idm_task);
1563a6d42e7dSPeter Dunlap 		mutex_exit(&itask->it_idm_task->idt_mutex);
1564a6d42e7dSPeter Dunlap 		/*
1565a6d42e7dSPeter Dunlap 		 * Fast path.  Cached status PDU's are already
1566a6d42e7dSPeter Dunlap 		 * initialized.  We just need to fill in
156760220f10SPriya Krishnan 		 * connection and task information. StatSN is
156860220f10SPriya Krishnan 		 * incremented by 1 for every status sent a
156960220f10SPriya Krishnan 		 * connection.
1570a6d42e7dSPeter Dunlap 		 */
1571a6d42e7dSPeter Dunlap 		pdu = kmem_cache_alloc(iscsit_status_pdu_cache, KM_SLEEP);
1572a6d42e7dSPeter Dunlap 		pdu->isp_ic = itask->it_ict->ict_ic;
1573a6d42e7dSPeter Dunlap 		pdu->isp_private = itask;
157460220f10SPriya Krishnan 		pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
1575a6d42e7dSPeter Dunlap 
1576a6d42e7dSPeter Dunlap 		rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
1577a6d42e7dSPeter Dunlap 		rsp->itt = itask->it_itt;
15781d7b78a3SPriya Krishnan 		/*
15791d7b78a3SPriya Krishnan 		 * ExpDataSN is the number of R2T and Data-In (read)
15801d7b78a3SPriya Krishnan 		 * PDUs the target has sent for the SCSI command.
15811d7b78a3SPriya Krishnan 		 *
15821d7b78a3SPriya Krishnan 		 * Since there is no support for bidirectional transfer
15831d7b78a3SPriya Krishnan 		 * yet, either idt_exp_datasn or idt_exp_rttsn, but not
15841d7b78a3SPriya Krishnan 		 * both is valid at any time
15851d7b78a3SPriya Krishnan 		 */
15861d7b78a3SPriya Krishnan 		rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ?
15871d7b78a3SPriya Krishnan 		    htonl(itask->it_idm_task->idt_exp_datasn):
15881d7b78a3SPriya Krishnan 		    htonl(itask->it_idm_task->idt_exp_rttsn);
1589a6d42e7dSPeter Dunlap 		rsp->cmd_status = task->task_scsi_status;
1590a6d42e7dSPeter Dunlap 		iscsit_pdu_tx(pdu);
1591a6d42e7dSPeter Dunlap 		return (STMF_SUCCESS);
1592a6d42e7dSPeter Dunlap 	} else {
1593a6d42e7dSPeter Dunlap 		if (itask->it_idm_task->idt_state != TASK_ACTIVE) {
1594a6d42e7dSPeter Dunlap 			mutex_exit(&itask->it_idm_task->idt_mutex);
159563528ae4SJames Moore 			return (STMF_FAILURE);
1596a6d42e7dSPeter Dunlap 		}
1597a6d42e7dSPeter Dunlap 		itask->it_idm_task->idt_state = TASK_COMPLETE;
1598a6d42e7dSPeter Dunlap 		/* PDU callback releases task hold */
1599a6d42e7dSPeter Dunlap 		idm_task_hold(itask->it_idm_task);
1600a6d42e7dSPeter Dunlap 		mutex_exit(&itask->it_idm_task->idt_mutex);
1601a6d42e7dSPeter Dunlap 
1602a6d42e7dSPeter Dunlap 		resp_datalen = (task->task_sense_length == 0) ? 0 :
1603a6d42e7dSPeter Dunlap 		    (task->task_sense_length + sizeof (uint16_t));
1604a6d42e7dSPeter Dunlap 
1605a6d42e7dSPeter Dunlap 		pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen);
1606a6d42e7dSPeter Dunlap 		idm_pdu_init(pdu, itask->it_ict->ict_ic, itask,
1607a6d42e7dSPeter Dunlap 		    iscsit_send_status_done);
160860220f10SPriya Krishnan 		pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
1609a6d42e7dSPeter Dunlap 
1610a6d42e7dSPeter Dunlap 		rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
1611a6d42e7dSPeter Dunlap 		bzero(rsp, sizeof (*rsp));
1612a6d42e7dSPeter Dunlap 		rsp->opcode = ISCSI_OP_SCSI_RSP;
1613a6d42e7dSPeter Dunlap 
1614a6d42e7dSPeter Dunlap 		rsp->flags = ISCSI_FLAG_FINAL;
1615a6d42e7dSPeter Dunlap 		if (task->task_status_ctrl & TASK_SCTRL_OVER) {
1616a6d42e7dSPeter Dunlap 			rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW;
1617a6d42e7dSPeter Dunlap 		} else if (task->task_status_ctrl & TASK_SCTRL_UNDER) {
1618a6d42e7dSPeter Dunlap 			rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
1619a6d42e7dSPeter Dunlap 		}
1620a6d42e7dSPeter Dunlap 
1621a6d42e7dSPeter Dunlap 		rsp->bi_residual_count = 0;
1622a6d42e7dSPeter Dunlap 		rsp->residual_count = htonl(task->task_resid);
1623a6d42e7dSPeter Dunlap 		rsp->itt = itask->it_itt;
1624a6d42e7dSPeter Dunlap 		rsp->response = ISCSI_STATUS_CMD_COMPLETED;
16251d7b78a3SPriya Krishnan 		rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ?
16261d7b78a3SPriya Krishnan 		    htonl(itask->it_idm_task->idt_exp_datasn):
16271d7b78a3SPriya Krishnan 		    htonl(itask->it_idm_task->idt_exp_rttsn);
1628a6d42e7dSPeter Dunlap 		rsp->cmd_status = task->task_scsi_status;
1629a6d42e7dSPeter Dunlap 		if (task->task_sense_length != 0) {
1630a6d42e7dSPeter Dunlap 			/*
1631a6d42e7dSPeter Dunlap 			 * Add a byte to provide the sense length in
1632a6d42e7dSPeter Dunlap 			 * the response
1633a6d42e7dSPeter Dunlap 			 */
1634a6d42e7dSPeter Dunlap 			*(uint16_t *)((void *)pdu->isp_data) =
1635a6d42e7dSPeter Dunlap 			    htons(task->task_sense_length);
1636a6d42e7dSPeter Dunlap 			bcopy(task->task_sense_data,
1637a6d42e7dSPeter Dunlap 			    (uint8_t *)pdu->isp_data +
1638a6d42e7dSPeter Dunlap 			    sizeof (uint16_t),
1639a6d42e7dSPeter Dunlap 			    task->task_sense_length);
1640a6d42e7dSPeter Dunlap 			hton24(rsp->dlength, resp_datalen);
1641a6d42e7dSPeter Dunlap 		}
1642a6d42e7dSPeter Dunlap 
164330e7468fSPeter Dunlap 		DTRACE_PROBE5(iscsi__scsi__response,
164430e7468fSPeter Dunlap 		    iscsit_conn_t *, itask->it_ict,
164530e7468fSPeter Dunlap 		    uint8_t, rsp->response,
164630e7468fSPeter Dunlap 		    uint8_t, rsp->cmd_status,
164730e7468fSPeter Dunlap 		    idm_pdu_t *, pdu,
164830e7468fSPeter Dunlap 		    scsi_task_t *, task);
164930e7468fSPeter Dunlap 
1650a6d42e7dSPeter Dunlap 		iscsit_pdu_tx(pdu);
1651a6d42e7dSPeter Dunlap 
1652a6d42e7dSPeter Dunlap 		return (STMF_SUCCESS);
1653a6d42e7dSPeter Dunlap 	}
1654a6d42e7dSPeter Dunlap }
1655a6d42e7dSPeter Dunlap 
1656a6d42e7dSPeter Dunlap /*ARGSUSED*/
1657a6d42e7dSPeter Dunlap static void
1658a6d42e7dSPeter Dunlap iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status)
1659a6d42e7dSPeter Dunlap {
1660bf604c64SPeter Dunlap 	iscsit_task_t	*itask;
1661bf604c64SPeter Dunlap 	boolean_t	aborted;
1662a6d42e7dSPeter Dunlap 
1663a6d42e7dSPeter Dunlap 	itask = pdu->isp_private;
1664bf604c64SPeter Dunlap 	aborted = itask->it_stmf_abort;
1665bf604c64SPeter Dunlap 
1666bf604c64SPeter Dunlap 	/*
1667bf604c64SPeter Dunlap 	 * After releasing the hold the task may be freed at any time so
1668bf604c64SPeter Dunlap 	 * don't touch it.
1669bf604c64SPeter Dunlap 	 */
1670a6d42e7dSPeter Dunlap 	idm_task_rele(itask->it_idm_task);
1671bf604c64SPeter Dunlap 	if (!aborted) {
1672bf604c64SPeter Dunlap 		stmf_send_status_done(itask->it_stmf_task,
1673bf604c64SPeter Dunlap 		    iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE);
1674bf604c64SPeter Dunlap 	}
1675a6d42e7dSPeter Dunlap 	kmem_cache_free(iscsit_status_pdu_cache, pdu);
1676a6d42e7dSPeter Dunlap }
1677a6d42e7dSPeter Dunlap 
1678a6d42e7dSPeter Dunlap /*ARGSUSED*/
1679a6d42e7dSPeter Dunlap static void
1680a6d42e7dSPeter Dunlap iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status)
1681a6d42e7dSPeter Dunlap {
1682a6d42e7dSPeter Dunlap 	iscsit_task_t	 *itask;
1683bf604c64SPeter Dunlap 	boolean_t	aborted;
1684a6d42e7dSPeter Dunlap 
1685a6d42e7dSPeter Dunlap 	itask = pdu->isp_private;
1686bf604c64SPeter Dunlap 	aborted = itask->it_stmf_abort;
1687bf604c64SPeter Dunlap 
1688bf604c64SPeter Dunlap 	/*
1689bf604c64SPeter Dunlap 	 * After releasing the hold the task may be freed at any time so
1690bf604c64SPeter Dunlap 	 * don't touch it.
1691bf604c64SPeter Dunlap 	 */
1692a6d42e7dSPeter Dunlap 	idm_task_rele(itask->it_idm_task);
1693bf604c64SPeter Dunlap 	if (!aborted) {
1694bf604c64SPeter Dunlap 		stmf_send_status_done(itask->it_stmf_task,
1695bf604c64SPeter Dunlap 		    iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE);
1696bf604c64SPeter Dunlap 	}
1697a6d42e7dSPeter Dunlap 	idm_pdu_free(pdu);
1698a6d42e7dSPeter Dunlap }
1699a6d42e7dSPeter Dunlap 
1700a6d42e7dSPeter Dunlap 
1701a6d42e7dSPeter Dunlap void
1702a6d42e7dSPeter Dunlap iscsit_lport_task_free(scsi_task_t *task)
1703a6d42e7dSPeter Dunlap {
1704a6d42e7dSPeter Dunlap 	iscsit_task_t *itask = task->task_port_private;
1705a6d42e7dSPeter Dunlap 
1706a6d42e7dSPeter Dunlap 	/* We only call idm_task_start for regular tasks, not task management */
1707a6d42e7dSPeter Dunlap 	if (task->task_mgmt_function == TM_NONE) {
1708a6d42e7dSPeter Dunlap 		idm_task_done(itask->it_idm_task);
1709a6d42e7dSPeter Dunlap 		iscsit_task_free(itask);
1710a6d42e7dSPeter Dunlap 		return;
1711a6d42e7dSPeter Dunlap 	} else {
1712a6d42e7dSPeter Dunlap 		iscsit_tm_task_free(itask);
1713a6d42e7dSPeter Dunlap 	}
1714a6d42e7dSPeter Dunlap }
1715a6d42e7dSPeter Dunlap 
1716a6d42e7dSPeter Dunlap /*ARGSUSED*/
1717a6d42e7dSPeter Dunlap stmf_status_t
1718a6d42e7dSPeter Dunlap iscsit_abort(stmf_local_port_t *lport, int abort_cmd, void *arg, uint32_t flags)
1719a6d42e7dSPeter Dunlap {
1720a6d42e7dSPeter Dunlap 	scsi_task_t	*st = (scsi_task_t *)arg;
1721a6d42e7dSPeter Dunlap 	iscsit_task_t	*iscsit_task;
1722a6d42e7dSPeter Dunlap 	idm_task_t	*idt;
1723a6d42e7dSPeter Dunlap 
1724a6d42e7dSPeter Dunlap 	/*
1725a6d42e7dSPeter Dunlap 	 * If this is a task management request then there's really not much to
1726a6d42e7dSPeter Dunlap 	 * do.
1727a6d42e7dSPeter Dunlap 	 */
1728a6d42e7dSPeter Dunlap 	if (st->task_mgmt_function != TM_NONE) {
1729a6d42e7dSPeter Dunlap 		return (STMF_ABORT_SUCCESS);
1730a6d42e7dSPeter Dunlap 	}
1731a6d42e7dSPeter Dunlap 
1732a6d42e7dSPeter Dunlap 	/*
1733a6d42e7dSPeter Dunlap 	 * Regular task, start cleaning up
1734a6d42e7dSPeter Dunlap 	 */
1735a6d42e7dSPeter Dunlap 	iscsit_task = st->task_port_private;
1736a6d42e7dSPeter Dunlap 	idt = iscsit_task->it_idm_task;
1737a6d42e7dSPeter Dunlap 	mutex_enter(&iscsit_task->it_mutex);
1738a6d42e7dSPeter Dunlap 	iscsit_task->it_stmf_abort = B_TRUE;
1739a6d42e7dSPeter Dunlap 	if (iscsit_task->it_aborted) {
1740a6d42e7dSPeter Dunlap 		mutex_exit(&iscsit_task->it_mutex);
174172cf3143Speter dunlap 		/*
174272cf3143Speter dunlap 		 * Task is no longer active
174372cf3143Speter dunlap 		 */
174472cf3143Speter dunlap 		iscsit_task_done(iscsit_task);
174572cf3143Speter dunlap 
1746a6d42e7dSPeter Dunlap 		/*
1747a6d42e7dSPeter Dunlap 		 * STMF specification is wrong... says to return
1748a6d42e7dSPeter Dunlap 		 * STMF_ABORTED, the code actually looks for
1749a6d42e7dSPeter Dunlap 		 * STMF_ABORT_SUCCESS.
1750a6d42e7dSPeter Dunlap 		 */
1751a6d42e7dSPeter Dunlap 		return (STMF_ABORT_SUCCESS);
1752a6d42e7dSPeter Dunlap 	} else {
1753a6d42e7dSPeter Dunlap 		mutex_exit(&iscsit_task->it_mutex);
1754a6d42e7dSPeter Dunlap 		/*
1755a6d42e7dSPeter Dunlap 		 * Call IDM to abort the task.  Due to a variety of
1756a6d42e7dSPeter Dunlap 		 * circumstances the task may already be in the process of
1757a6d42e7dSPeter Dunlap 		 * aborting.
1758a6d42e7dSPeter Dunlap 		 * We'll let IDM worry about rationalizing all that except
1759a6d42e7dSPeter Dunlap 		 * for one particular instance.  If the state of the task
1760a6d42e7dSPeter Dunlap 		 * is TASK_COMPLETE, we need to indicate to the framework
1761a6d42e7dSPeter Dunlap 		 * that we are in fact done.  This typically happens with
1762a6d42e7dSPeter Dunlap 		 * framework-initiated task management type requests
1763a6d42e7dSPeter Dunlap 		 * (e.g. abort task).
1764a6d42e7dSPeter Dunlap 		 */
1765a6d42e7dSPeter Dunlap 		if (idt->idt_state == TASK_COMPLETE) {
1766a6d42e7dSPeter Dunlap 			idm_refcnt_wait_ref(&idt->idt_refcnt);
1767a6d42e7dSPeter Dunlap 			return (STMF_ABORT_SUCCESS);
1768a6d42e7dSPeter Dunlap 		} else {
1769a6d42e7dSPeter Dunlap 			idm_task_abort(idt->idt_ic, idt, AT_TASK_MGMT_ABORT);
1770a6d42e7dSPeter Dunlap 			return (STMF_SUCCESS);
1771a6d42e7dSPeter Dunlap 		}
1772a6d42e7dSPeter Dunlap 	}
1773a6d42e7dSPeter Dunlap 
1774a6d42e7dSPeter Dunlap 	/*NOTREACHED*/
1775a6d42e7dSPeter Dunlap }
1776a6d42e7dSPeter Dunlap 
1777a6d42e7dSPeter Dunlap /*ARGSUSED*/
1778a6d42e7dSPeter Dunlap void
1779a6d42e7dSPeter Dunlap iscsit_ctl(stmf_local_port_t *lport, int cmd, void *arg)
1780a6d42e7dSPeter Dunlap {
1781a6d42e7dSPeter Dunlap 	iscsit_tgt_t		*iscsit_tgt;
1782a6d42e7dSPeter Dunlap 
1783a6d42e7dSPeter Dunlap 	ASSERT((cmd == STMF_CMD_LPORT_ONLINE) ||
1784a6d42e7dSPeter Dunlap 	    (cmd == STMF_ACK_LPORT_ONLINE_COMPLETE) ||
1785a6d42e7dSPeter Dunlap 	    (cmd == STMF_CMD_LPORT_OFFLINE) ||
1786a6d42e7dSPeter Dunlap 	    (cmd == STMF_ACK_LPORT_OFFLINE_COMPLETE));
1787a6d42e7dSPeter Dunlap 
1788a6d42e7dSPeter Dunlap 	iscsit_tgt = (iscsit_tgt_t *)lport->lport_port_private;
1789a6d42e7dSPeter Dunlap 
1790a6d42e7dSPeter Dunlap 	switch (cmd) {
1791a6d42e7dSPeter Dunlap 	case STMF_CMD_LPORT_ONLINE:
1792a6d42e7dSPeter Dunlap 		iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_REQ);
1793a6d42e7dSPeter Dunlap 		break;
1794a6d42e7dSPeter Dunlap 	case STMF_CMD_LPORT_OFFLINE:
1795a6d42e7dSPeter Dunlap 		iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_REQ);
1796a6d42e7dSPeter Dunlap 		break;
1797a6d42e7dSPeter Dunlap 	case STMF_ACK_LPORT_ONLINE_COMPLETE:
1798a6d42e7dSPeter Dunlap 		iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_COMPLETE_ACK);
1799a6d42e7dSPeter Dunlap 		break;
1800a6d42e7dSPeter Dunlap 	case STMF_ACK_LPORT_OFFLINE_COMPLETE:
1801a6d42e7dSPeter Dunlap 		iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_COMPLETE_ACK);
1802a6d42e7dSPeter Dunlap 		break;
1803a6d42e7dSPeter Dunlap 
1804a6d42e7dSPeter Dunlap 	default:
1805a6d42e7dSPeter Dunlap 		break;
1806a6d42e7dSPeter Dunlap 	}
1807a6d42e7dSPeter Dunlap }
1808a6d42e7dSPeter Dunlap 
1809a6d42e7dSPeter Dunlap static stmf_status_t
1810a6d42e7dSPeter Dunlap iscsit_idm_to_stmf(idm_status_t idmrc)
1811a6d42e7dSPeter Dunlap {
1812a6d42e7dSPeter Dunlap 	switch (idmrc) {
1813a6d42e7dSPeter Dunlap 	case IDM_STATUS_SUCCESS:
1814a6d42e7dSPeter Dunlap 		return (STMF_SUCCESS);
1815a6d42e7dSPeter Dunlap 	default:
1816a6d42e7dSPeter Dunlap 		return (STMF_FAILURE);
1817a6d42e7dSPeter Dunlap 	}
1818a6d42e7dSPeter Dunlap 	/*NOTREACHED*/
1819a6d42e7dSPeter Dunlap }
1820a6d42e7dSPeter Dunlap 
1821a6d42e7dSPeter Dunlap 
1822a6d42e7dSPeter Dunlap /*
1823a6d42e7dSPeter Dunlap  * ISCSI protocol
1824a6d42e7dSPeter Dunlap  */
1825a6d42e7dSPeter Dunlap 
1826a6d42e7dSPeter Dunlap void
1827a6d42e7dSPeter Dunlap iscsit_op_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu)
1828a6d42e7dSPeter Dunlap {
1829a6d42e7dSPeter Dunlap 	iscsit_conn_t		*ict;
1830a6d42e7dSPeter Dunlap 	iscsit_task_t		*itask;
1831a6d42e7dSPeter Dunlap 	scsi_task_t		*task;
1832a6d42e7dSPeter Dunlap 	iscsit_buf_t		*ibuf;
1833a6d42e7dSPeter Dunlap 	iscsi_scsi_cmd_hdr_t	*iscsi_scsi =
1834a6d42e7dSPeter Dunlap 	    (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
1835a6d42e7dSPeter Dunlap 	iscsi_addl_hdr_t	*ahs_hdr;
1836a6d42e7dSPeter Dunlap 	uint16_t		addl_cdb_len = 0;
1837a6d42e7dSPeter Dunlap 
1838a6d42e7dSPeter Dunlap 	ict = ic->ic_handle;
1839a6d42e7dSPeter Dunlap 
1840a6d42e7dSPeter Dunlap 	itask = iscsit_task_alloc(ict);
1841a6d42e7dSPeter Dunlap 	if (itask == NULL) {
184272cf3143Speter dunlap 		/* Finish processing request */
184372cf3143Speter dunlap 		iscsit_set_cmdsn(ict, rx_pdu);
184472cf3143Speter dunlap 
1845a6d42e7dSPeter Dunlap 		iscsit_send_direct_scsi_resp(ict, rx_pdu,
1846a6d42e7dSPeter Dunlap 		    ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY);
1847a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
1848a6d42e7dSPeter Dunlap 		return;
1849a6d42e7dSPeter Dunlap 	}
1850a6d42e7dSPeter Dunlap 
1851a6d42e7dSPeter Dunlap 
1852a6d42e7dSPeter Dunlap 	/*
1853a6d42e7dSPeter Dunlap 	 * Note CmdSN and ITT in task.  IDM will have already validated this
1854a6d42e7dSPeter Dunlap 	 * request against the connection state so we don't need to check
1855a6d42e7dSPeter Dunlap 	 * that (the connection may have changed state in the meantime but
1856a6d42e7dSPeter Dunlap 	 * we will catch that when we try to send a response)
1857a6d42e7dSPeter Dunlap 	 */
1858a6d42e7dSPeter Dunlap 	itask->it_cmdsn = ntohl(iscsi_scsi->cmdsn);
1859a6d42e7dSPeter Dunlap 	itask->it_itt = iscsi_scsi->itt;
1860a6d42e7dSPeter Dunlap 
1861a6d42e7dSPeter Dunlap 	/*
1862a6d42e7dSPeter Dunlap 	 * Check for extended CDB AHS
1863a6d42e7dSPeter Dunlap 	 */
1864a6d42e7dSPeter Dunlap 	if (iscsi_scsi->hlength > 0) {
1865a6d42e7dSPeter Dunlap 		ahs_hdr = (iscsi_addl_hdr_t *)iscsi_scsi;
1866a6d42e7dSPeter Dunlap 		addl_cdb_len = ((ahs_hdr->ahs_hlen_hi << 8) |
1867a6d42e7dSPeter Dunlap 		    ahs_hdr->ahs_hlen_lo) - 1; /* Adjust for reserved byte */
1868a6d42e7dSPeter Dunlap 		if (((addl_cdb_len + 4) / sizeof (uint32_t)) >
1869a6d42e7dSPeter Dunlap 		    iscsi_scsi->hlength) {
1870a6d42e7dSPeter Dunlap 			/* Mangled header info, drop it */
1871a6d42e7dSPeter Dunlap 			idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
1872a6d42e7dSPeter Dunlap 			return;
1873a6d42e7dSPeter Dunlap 		}
1874a6d42e7dSPeter Dunlap 	}
1875a6d42e7dSPeter Dunlap 
1876a6d42e7dSPeter Dunlap 	ict = rx_pdu->isp_ic->ic_handle; /* IDM client private */
1877a6d42e7dSPeter Dunlap 
187872cf3143Speter dunlap 	/*
187972cf3143Speter dunlap 	 * Add task to session list.  This function will also check to
188072cf3143Speter dunlap 	 * ensure that the task does not already exist.
188172cf3143Speter dunlap 	 */
188272cf3143Speter dunlap 	if (iscsit_task_start(itask) != IDM_STATUS_SUCCESS) {
188372cf3143Speter dunlap 		/*
188472cf3143Speter dunlap 		 * Task exists, free all resources and reject.  Don't
188572cf3143Speter dunlap 		 * update expcmdsn in this case because RFC 3720 says
188672cf3143Speter dunlap 		 * "The CmdSN of the rejected command PDU (if it is a
188772cf3143Speter dunlap 		 * non-immediate command) MUST NOT be considered received
188872cf3143Speter dunlap 		 * by the target (i.e., a command sequence gap must be
188972cf3143Speter dunlap 		 * assumed for the CmdSN), even though the CmdSN of the
189072cf3143Speter dunlap 		 * rejected command PDU may be reliably ascertained.  Upon
189172cf3143Speter dunlap 		 * receiving the Reject, the initiator MUST plug the CmdSN
189272cf3143Speter dunlap 		 * gap in order to continue to use the session.  The gap
189372cf3143Speter dunlap 		 * may be plugged either by transmitting a command PDU
189472cf3143Speter dunlap 		 * with the same CmdSN, or by aborting the task (see section
189572cf3143Speter dunlap 		 * 6.9 on how an abort may plug a CmdSN gap)." (Section 6.3)
189672cf3143Speter dunlap 		 */
189772cf3143Speter dunlap 		iscsit_task_free(itask);
189872cf3143Speter dunlap 		iscsit_send_reject(ict, rx_pdu, ISCSI_REJECT_TASK_IN_PROGRESS);
189972cf3143Speter dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
190072cf3143Speter dunlap 		return;
190172cf3143Speter dunlap 	}
190272cf3143Speter dunlap 
190372cf3143Speter dunlap 	/* Update sequence numbers */
190472cf3143Speter dunlap 	iscsit_set_cmdsn(ict, rx_pdu);
190572cf3143Speter dunlap 
190672cf3143Speter dunlap 	/*
190772cf3143Speter dunlap 	 * Allocate STMF task
190872cf3143Speter dunlap 	 */
1909a6d42e7dSPeter Dunlap 	itask->it_stmf_task = stmf_task_alloc(
1910a6d42e7dSPeter Dunlap 	    itask->it_ict->ict_sess->ist_lport,
1911a6d42e7dSPeter Dunlap 	    itask->it_ict->ict_sess->ist_stmf_sess, iscsi_scsi->lun,
1912a6d42e7dSPeter Dunlap 	    16 + addl_cdb_len, 0);
1913a6d42e7dSPeter Dunlap 	if (itask->it_stmf_task == NULL) {
1914a6d42e7dSPeter Dunlap 		/*
1915a6d42e7dSPeter Dunlap 		 * Either stmf really couldn't get memory for a task or,
1916a6d42e7dSPeter Dunlap 		 * more likely, the LU is currently in reset.  Either way
1917a6d42e7dSPeter Dunlap 		 * we have no choice but to fail the request.
1918a6d42e7dSPeter Dunlap 		 */
191972cf3143Speter dunlap 		iscsit_task_done(itask);
1920a6d42e7dSPeter Dunlap 		iscsit_task_free(itask);
1921a6d42e7dSPeter Dunlap 		iscsit_send_direct_scsi_resp(ict, rx_pdu,
1922a6d42e7dSPeter Dunlap 		    ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY);
192372cf3143Speter dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
1924a6d42e7dSPeter Dunlap 		return;
1925a6d42e7dSPeter Dunlap 	}
1926a6d42e7dSPeter Dunlap 
1927a6d42e7dSPeter Dunlap 	task = itask->it_stmf_task;
1928a6d42e7dSPeter Dunlap 	task->task_port_private = itask;
1929a6d42e7dSPeter Dunlap 
1930a6d42e7dSPeter Dunlap 	bcopy(iscsi_scsi->lun, task->task_lun_no, sizeof (task->task_lun_no));
1931a6d42e7dSPeter Dunlap 
1932a6d42e7dSPeter Dunlap 	/*
1933a6d42e7dSPeter Dunlap 	 * iSCSI and Comstar use the same values.  Should we rely on this
1934a6d42e7dSPeter Dunlap 	 * or translate them bit-wise?
1935a6d42e7dSPeter Dunlap 	 */
1936a6d42e7dSPeter Dunlap 
1937a6d42e7dSPeter Dunlap 	task->task_flags =
1938a6d42e7dSPeter Dunlap 	    (((iscsi_scsi->flags & ISCSI_FLAG_CMD_READ) ? TF_READ_DATA : 0) |
1939a6d42e7dSPeter Dunlap 	    ((iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? TF_WRITE_DATA : 0) |
1940a6d42e7dSPeter Dunlap 	    ((rx_pdu->isp_datalen == 0) ? 0 : TF_INITIAL_BURST));
1941a6d42e7dSPeter Dunlap 
1942a6d42e7dSPeter Dunlap 	switch (iscsi_scsi->flags & ISCSI_FLAG_CMD_ATTR_MASK) {
1943a6d42e7dSPeter Dunlap 	case ISCSI_ATTR_UNTAGGED:
1944a6d42e7dSPeter Dunlap 		break;
1945a6d42e7dSPeter Dunlap 	case ISCSI_ATTR_SIMPLE:
1946a6d42e7dSPeter Dunlap 		task->task_additional_flags |= TF_ATTR_SIMPLE_QUEUE;
1947a6d42e7dSPeter Dunlap 		break;
1948a6d42e7dSPeter Dunlap 	case ISCSI_ATTR_ORDERED:
1949a6d42e7dSPeter Dunlap 		task->task_additional_flags |= TF_ATTR_ORDERED_QUEUE;
1950a6d42e7dSPeter Dunlap 		break;
1951a6d42e7dSPeter Dunlap 	case ISCSI_ATTR_HEAD_OF_QUEUE:
1952a6d42e7dSPeter Dunlap 		task->task_additional_flags |= TF_ATTR_HEAD_OF_QUEUE;
1953a6d42e7dSPeter Dunlap 		break;
1954a6d42e7dSPeter Dunlap 	case ISCSI_ATTR_ACA:
1955a6d42e7dSPeter Dunlap 		task->task_additional_flags |= TF_ATTR_ACA;
1956a6d42e7dSPeter Dunlap 		break;
1957a6d42e7dSPeter Dunlap 	default:
1958a6d42e7dSPeter Dunlap 		/* Protocol error but just take it, treat as untagged */
1959a6d42e7dSPeter Dunlap 		break;
1960a6d42e7dSPeter Dunlap 	}
1961a6d42e7dSPeter Dunlap 
1962a6d42e7dSPeter Dunlap 
1963a6d42e7dSPeter Dunlap 	task->task_additional_flags = 0;
1964a6d42e7dSPeter Dunlap 	task->task_priority = 0;
1965a6d42e7dSPeter Dunlap 	task->task_mgmt_function = TM_NONE;
1966a6d42e7dSPeter Dunlap 
1967a6d42e7dSPeter Dunlap 	/*
1968a6d42e7dSPeter Dunlap 	 * This "task_max_nbufs" doesn't map well to BIDI.  We probably need
1969a6d42e7dSPeter Dunlap 	 * parameter for each direction.  "MaxOutstandingR2T" may very well
1970a6d42e7dSPeter Dunlap 	 * be set to one which could prevent us from doing simultaneous
1971a6d42e7dSPeter Dunlap 	 * transfers in each direction.
1972a6d42e7dSPeter Dunlap 	 */
1973a6d42e7dSPeter Dunlap 	task->task_max_nbufs = (iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ?
1974a6d42e7dSPeter Dunlap 	    ict->ict_op.op_max_outstanding_r2t : STMF_BUFS_MAX;
1975a6d42e7dSPeter Dunlap 	task->task_cmd_seq_no = ntohl(iscsi_scsi->itt);
1976a6d42e7dSPeter Dunlap 	task->task_expected_xfer_length = ntohl(iscsi_scsi->data_length);
1977a6d42e7dSPeter Dunlap 
1978a6d42e7dSPeter Dunlap 	/* Copy CDB */
1979a6d42e7dSPeter Dunlap 	bcopy(iscsi_scsi->scb, task->task_cdb, 16);
1980a6d42e7dSPeter Dunlap 	if (addl_cdb_len > 0) {
1981a6d42e7dSPeter Dunlap 		bcopy(ahs_hdr->ahs_extscb, task->task_cdb + 16, addl_cdb_len);
1982a6d42e7dSPeter Dunlap 	}
1983a6d42e7dSPeter Dunlap 
1984a668b114SPriya Krishnan 	DTRACE_ISCSI_3(scsi__command, idm_conn_t *, ic,
1985a668b114SPriya Krishnan 	    iscsi_scsi_cmd_hdr_t *, (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr,
1986a668b114SPriya Krishnan 	    scsi_task_t *, task);
1987a668b114SPriya Krishnan 
1988a6d42e7dSPeter Dunlap 	/*
1989a6d42e7dSPeter Dunlap 	 * Copy the transport header into the task handle from the PDU
1990a6d42e7dSPeter Dunlap 	 * handle. The transport header describes this task's remote tagged
1991a6d42e7dSPeter Dunlap 	 * buffer.
1992a6d42e7dSPeter Dunlap 	 */
1993a6d42e7dSPeter Dunlap 	if (rx_pdu->isp_transport_hdrlen != 0) {
1994a6d42e7dSPeter Dunlap 		bcopy(rx_pdu->isp_transport_hdr,
1995a6d42e7dSPeter Dunlap 		    itask->it_idm_task->idt_transport_hdr,
1996a6d42e7dSPeter Dunlap 		    rx_pdu->isp_transport_hdrlen);
1997a6d42e7dSPeter Dunlap 	}
1998a6d42e7dSPeter Dunlap 
1999a6d42e7dSPeter Dunlap 	/*
2000a6d42e7dSPeter Dunlap 	 * Tell IDM about our new active task
2001a6d42e7dSPeter Dunlap 	 */
2002a6d42e7dSPeter Dunlap 	idm_task_start(itask->it_idm_task, (uintptr_t)itask->it_itt);
2003a6d42e7dSPeter Dunlap 
2004a6d42e7dSPeter Dunlap 	/*
2005a6d42e7dSPeter Dunlap 	 * If we have any immediate data then setup the immediate buffer
2006a6d42e7dSPeter Dunlap 	 * context that comes with the task
2007a6d42e7dSPeter Dunlap 	 */
2008a6d42e7dSPeter Dunlap 	if (rx_pdu->isp_datalen) {
2009a6d42e7dSPeter Dunlap 		ibuf = itask->it_immed_data;
2010a6d42e7dSPeter Dunlap 		ibuf->ibuf_immed_data_pdu = rx_pdu;
2011a6d42e7dSPeter Dunlap 		ibuf->ibuf_stmf_buf->db_data_size = rx_pdu->isp_datalen;
2012a6d42e7dSPeter Dunlap 		ibuf->ibuf_stmf_buf->db_buf_size = rx_pdu->isp_datalen;
2013a6d42e7dSPeter Dunlap 		ibuf->ibuf_stmf_buf->db_relative_offset = 0;
2014a6d42e7dSPeter Dunlap 		ibuf->ibuf_stmf_buf->db_sglist[0].seg_length =
2015a6d42e7dSPeter Dunlap 		    rx_pdu->isp_datalen;
2016a6d42e7dSPeter Dunlap 		ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr = rx_pdu->isp_data;
2017a6d42e7dSPeter Dunlap 
2018a668b114SPriya Krishnan 		DTRACE_ISCSI_8(xfer__start, idm_conn_t *, ic,
2019a668b114SPriya Krishnan 		    uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr,
2020a668b114SPriya Krishnan 		    uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset,
2021a668b114SPriya Krishnan 		    uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */
2022a668b114SPriya Krishnan 		    uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI);
2023a668b114SPriya Krishnan 
20243badd853SPriya Krishnan 		/*
20253badd853SPriya Krishnan 		 * For immediate data transfer, there is no callback from
20263badd853SPriya Krishnan 		 * stmf to indicate that the initial burst of data is
20273badd853SPriya Krishnan 		 * transferred successfully. In some cases, the task can
20283badd853SPriya Krishnan 		 * get freed before execution returns from stmf_post_task.
20293badd853SPriya Krishnan 		 * Although this xfer-start/done probe accurately tracks
20303badd853SPriya Krishnan 		 * the size of the transfer, it does only provide a best
20313badd853SPriya Krishnan 		 * effort on the timing of the transfer.
20323badd853SPriya Krishnan 		 */
2033a668b114SPriya Krishnan 		DTRACE_ISCSI_8(xfer__done, idm_conn_t *, ic,
2034a668b114SPriya Krishnan 		    uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr,
2035a668b114SPriya Krishnan 		    uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset,
2036a668b114SPriya Krishnan 		    uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */
2037a668b114SPriya Krishnan 		    uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI);
20383badd853SPriya Krishnan 
20393badd853SPriya Krishnan 		stmf_post_task(task, ibuf->ibuf_stmf_buf);
2040a6d42e7dSPeter Dunlap 	} else {
20413badd853SPriya Krishnan 
2042a6d42e7dSPeter Dunlap 		stmf_post_task(task, NULL);
2043a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2044a6d42e7dSPeter Dunlap 	}
2045a6d42e7dSPeter Dunlap }
2046a6d42e7dSPeter Dunlap 
2047a6d42e7dSPeter Dunlap /*ARGSUSED*/
2048a6d42e7dSPeter Dunlap void
2049a6d42e7dSPeter Dunlap iscsit_deferred_dispatch(idm_pdu_t *rx_pdu)
2050a6d42e7dSPeter Dunlap {
2051a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle;
2052a6d42e7dSPeter Dunlap 
2053a6d42e7dSPeter Dunlap 	/*
2054a6d42e7dSPeter Dunlap 	 * If the connection has been lost then ignore new PDU's
2055a6d42e7dSPeter Dunlap 	 */
2056a6d42e7dSPeter Dunlap 	mutex_enter(&ict->ict_mutex);
2057a6d42e7dSPeter Dunlap 	if (ict->ict_lost) {
2058a6d42e7dSPeter Dunlap 		mutex_exit(&ict->ict_mutex);
2059a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2060a6d42e7dSPeter Dunlap 		return;
2061a6d42e7dSPeter Dunlap 	}
2062a6d42e7dSPeter Dunlap 
2063a6d42e7dSPeter Dunlap 	/*
2064a6d42e7dSPeter Dunlap 	 * Grab a hold on the connection to prevent it from going away
2065a6d42e7dSPeter Dunlap 	 * between now and when the taskq function is called.
2066a6d42e7dSPeter Dunlap 	 */
2067a6d42e7dSPeter Dunlap 	iscsit_conn_dispatch_hold(ict);
2068a6d42e7dSPeter Dunlap 	mutex_exit(&ict->ict_mutex);
2069a6d42e7dSPeter Dunlap 
2070a6d42e7dSPeter Dunlap 	if (taskq_dispatch(iscsit_global.global_dispatch_taskq,
2071a6d42e7dSPeter Dunlap 	    iscsit_deferred, rx_pdu, DDI_NOSLEEP) == NULL) {
2072a6d42e7dSPeter Dunlap 		/*
2073a6d42e7dSPeter Dunlap 		 * In the unlikely scenario that we couldn't get the resources
2074a6d42e7dSPeter Dunlap 		 * to dispatch the PDU then just drop it.
2075a6d42e7dSPeter Dunlap 		 */
2076a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2077a6d42e7dSPeter Dunlap 		idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL);
2078a6d42e7dSPeter Dunlap 		iscsit_conn_dispatch_rele(ict);
2079a6d42e7dSPeter Dunlap 	}
2080a6d42e7dSPeter Dunlap }
2081a6d42e7dSPeter Dunlap 
2082a6d42e7dSPeter Dunlap static void
2083a6d42e7dSPeter Dunlap iscsit_deferred(void *rx_pdu_void)
2084a6d42e7dSPeter Dunlap {
2085a6d42e7dSPeter Dunlap 	idm_pdu_t *rx_pdu = rx_pdu_void;
2086a6d42e7dSPeter Dunlap 	idm_conn_t *ic = rx_pdu->isp_ic;
2087a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ic->ic_handle;
2088a6d42e7dSPeter Dunlap 
2089a6d42e7dSPeter Dunlap 	switch (IDM_PDU_OPCODE(rx_pdu)) {
2090a6d42e7dSPeter Dunlap 	case ISCSI_OP_NOOP_OUT:
2091a6d42e7dSPeter Dunlap 		iscsit_set_cmdsn(ict, rx_pdu);
2092a6d42e7dSPeter Dunlap 		iscsit_pdu_op_noop(ict, rx_pdu);
2093a6d42e7dSPeter Dunlap 		break;
2094a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGIN_CMD:
2095a6d42e7dSPeter Dunlap 		iscsit_pdu_op_login_cmd(ict, rx_pdu);
2096a6d42e7dSPeter Dunlap 		break;
2097a6d42e7dSPeter Dunlap 	case ISCSI_OP_TEXT_CMD:
2098a6d42e7dSPeter Dunlap 		iscsit_set_cmdsn(ict, rx_pdu);
2099a6d42e7dSPeter Dunlap 		iscsit_pdu_op_text_cmd(ict, rx_pdu);
2100a6d42e7dSPeter Dunlap 		break;
2101a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGOUT_CMD:
2102a6d42e7dSPeter Dunlap 		iscsit_set_cmdsn(ict, rx_pdu);
2103a6d42e7dSPeter Dunlap 		iscsit_pdu_op_logout_cmd(ict, rx_pdu);
2104a6d42e7dSPeter Dunlap 		break;
2105a6d42e7dSPeter Dunlap 	default:
2106a6d42e7dSPeter Dunlap 		/* Protocol error.  IDM should have caught this */
2107a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL);
2108a6d42e7dSPeter Dunlap 		ASSERT(0);
2109a6d42e7dSPeter Dunlap 		break;
2110a6d42e7dSPeter Dunlap 	}
2111a6d42e7dSPeter Dunlap 
2112a6d42e7dSPeter Dunlap 	iscsit_conn_dispatch_rele(ict);
2113a6d42e7dSPeter Dunlap }
2114a6d42e7dSPeter Dunlap 
2115a6d42e7dSPeter Dunlap static void
2116a6d42e7dSPeter Dunlap iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu,
2117a6d42e7dSPeter Dunlap     uint8_t response, uint8_t cmd_status)
2118a6d42e7dSPeter Dunlap {
2119a6d42e7dSPeter Dunlap 	idm_pdu_t			*rsp_pdu;
2120a6d42e7dSPeter Dunlap 	idm_conn_t			*ic;
2121a6d42e7dSPeter Dunlap 	iscsi_scsi_rsp_hdr_t		*resp;
212230e7468fSPeter Dunlap 	iscsi_scsi_cmd_hdr_t		*req =
212330e7468fSPeter Dunlap 	    (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
2124a6d42e7dSPeter Dunlap 
2125a6d42e7dSPeter Dunlap 	ic = ict->ict_ic;
2126a6d42e7dSPeter Dunlap 
2127a6d42e7dSPeter Dunlap 	rsp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_rsp_hdr_t), 0);
2128a6d42e7dSPeter Dunlap 	idm_pdu_init(rsp_pdu, ic, NULL, NULL);
212960220f10SPriya Krishnan 	/*
213060220f10SPriya Krishnan 	 * StatSN is incremented by 1 for every response sent on
213160220f10SPriya Krishnan 	 * a connection except for responses sent as a result of
213260220f10SPriya Krishnan 	 * a retry or SNACK
213360220f10SPriya Krishnan 	 */
213460220f10SPriya Krishnan 	rsp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
213560220f10SPriya Krishnan 
2136a6d42e7dSPeter Dunlap 	resp = (iscsi_scsi_rsp_hdr_t *)rsp_pdu->isp_hdr;
2137a6d42e7dSPeter Dunlap 
2138a6d42e7dSPeter Dunlap 	resp->opcode = ISCSI_OP_SCSI_RSP;
2139a6d42e7dSPeter Dunlap 	resp->flags = ISCSI_FLAG_FINAL;
2140a6d42e7dSPeter Dunlap 	resp->response = response;
2141a6d42e7dSPeter Dunlap 	resp->cmd_status = cmd_status;
214230e7468fSPeter Dunlap 	resp->itt = req->itt;
214330e7468fSPeter Dunlap 	if ((response == ISCSI_STATUS_CMD_COMPLETED) &&
214430e7468fSPeter Dunlap 	    (req->data_length != 0) &&
214530e7468fSPeter Dunlap 	    ((req->flags & ISCSI_FLAG_CMD_READ) ||
214630e7468fSPeter Dunlap 	    (req->flags & ISCSI_FLAG_CMD_WRITE))) {
214730e7468fSPeter Dunlap 		resp->flags |= ISCSI_FLAG_CMD_UNDERFLOW;
214830e7468fSPeter Dunlap 		resp->residual_count = req->data_length;
214930e7468fSPeter Dunlap 	}
215030e7468fSPeter Dunlap 
215130e7468fSPeter Dunlap 	DTRACE_PROBE4(iscsi__scsi__direct__response,
215230e7468fSPeter Dunlap 	    iscsit_conn_t *, ict,
215330e7468fSPeter Dunlap 	    uint8_t, resp->response,
215430e7468fSPeter Dunlap 	    uint8_t, resp->cmd_status,
215530e7468fSPeter Dunlap 	    idm_pdu_t *, rsp_pdu);
2156a6d42e7dSPeter Dunlap 
2157a6d42e7dSPeter Dunlap 	iscsit_pdu_tx(rsp_pdu);
2158a6d42e7dSPeter Dunlap }
2159a6d42e7dSPeter Dunlap 
2160a6d42e7dSPeter Dunlap void
2161a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, uint8_t tm_status)
2162a6d42e7dSPeter Dunlap {
2163a6d42e7dSPeter Dunlap 	iscsi_scsi_task_mgt_rsp_hdr_t	*tm_resp;
2164a6d42e7dSPeter Dunlap 
216560220f10SPriya Krishnan 	/*
216660220f10SPriya Krishnan 	 * The target must take note of the last-sent StatSN.
216760220f10SPriya Krishnan 	 * The StatSN is to be incremented after sending a
216860220f10SPriya Krishnan 	 * task management response. Digest recovery can only
216960220f10SPriya Krishnan 	 * work if StatSN is incremented.
217060220f10SPriya Krishnan 	 */
217160220f10SPriya Krishnan 	tm_resp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2172a6d42e7dSPeter Dunlap 	tm_resp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr;
2173a6d42e7dSPeter Dunlap 	tm_resp->response = tm_status;
217430e7468fSPeter Dunlap 
217530e7468fSPeter Dunlap 	DTRACE_PROBE3(iscsi__scsi__tm__response,
217630e7468fSPeter Dunlap 	    iscsit_conn_t *, tm_resp_pdu->isp_ic->ic_handle,
217730e7468fSPeter Dunlap 	    uint8_t, tm_resp->response,
217830e7468fSPeter Dunlap 	    idm_pdu_t *, tm_resp_pdu);
2179a6d42e7dSPeter Dunlap 	iscsit_pdu_tx(tm_resp_pdu);
2180a6d42e7dSPeter Dunlap }
2181a6d42e7dSPeter Dunlap 
2182a6d42e7dSPeter Dunlap void
2183a6d42e7dSPeter Dunlap iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2184a6d42e7dSPeter Dunlap {
2185a6d42e7dSPeter Dunlap 	idm_pdu_t			*tm_resp_pdu;
2186a6d42e7dSPeter Dunlap 	iscsit_task_t			*itask;
2187a6d42e7dSPeter Dunlap 	iscsit_task_t			*tm_itask;
2188a6d42e7dSPeter Dunlap 	scsi_task_t			*task;
2189a6d42e7dSPeter Dunlap 	iscsi_scsi_task_mgt_hdr_t 	*iscsi_tm =
2190a6d42e7dSPeter Dunlap 	    (iscsi_scsi_task_mgt_hdr_t *)rx_pdu->isp_hdr;
2191a6d42e7dSPeter Dunlap 	iscsi_scsi_task_mgt_rsp_hdr_t 	*iscsi_tm_rsp =
2192a6d42e7dSPeter Dunlap 	    (iscsi_scsi_task_mgt_rsp_hdr_t *)rx_pdu->isp_hdr;
2193a6d42e7dSPeter Dunlap 	uint32_t			rtt, cmdsn, refcmdsn;
2194a6d42e7dSPeter Dunlap 	uint8_t				tm_func;
2195a6d42e7dSPeter Dunlap 
2196a6d42e7dSPeter Dunlap 	/*
2197a6d42e7dSPeter Dunlap 	 * Setup response PDU (response field will get filled in later)
2198a6d42e7dSPeter Dunlap 	 */
2199a6d42e7dSPeter Dunlap 	tm_resp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_task_mgt_rsp_hdr_t), 0);
2200a6d42e7dSPeter Dunlap 	if (tm_resp_pdu == NULL) {
2201a6d42e7dSPeter Dunlap 		/* Can't respond, just drop it */
2202a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2203a6d42e7dSPeter Dunlap 		return;
2204a6d42e7dSPeter Dunlap 	}
2205a6d42e7dSPeter Dunlap 	idm_pdu_init(tm_resp_pdu, ict->ict_ic, NULL, NULL);
2206a6d42e7dSPeter Dunlap 	iscsi_tm_rsp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr;
2207a6d42e7dSPeter Dunlap 	bzero(iscsi_tm_rsp, sizeof (iscsi_scsi_task_mgt_rsp_hdr_t));
2208a6d42e7dSPeter Dunlap 	iscsi_tm_rsp->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP;
2209a6d42e7dSPeter Dunlap 	iscsi_tm_rsp->flags = ISCSI_FLAG_FINAL;
2210a6d42e7dSPeter Dunlap 	iscsi_tm_rsp->itt = rx_pdu->isp_hdr->itt;
2211a6d42e7dSPeter Dunlap 
2212a6d42e7dSPeter Dunlap 	/*
2213a6d42e7dSPeter Dunlap 	 * Figure out what we're being asked to do.
2214a6d42e7dSPeter Dunlap 	 */
221530e7468fSPeter Dunlap 	DTRACE_PROBE4(iscsi__scsi__tm__request,
221630e7468fSPeter Dunlap 	    iscsit_conn_t *, ict,
221730e7468fSPeter Dunlap 	    uint8_t, (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK),
221830e7468fSPeter Dunlap 	    uint32_t, iscsi_tm->rtt,
221930e7468fSPeter Dunlap 	    idm_pdu_t *, rx_pdu);
2220a6d42e7dSPeter Dunlap 	switch (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK) {
2221a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_ABORT_TASK:
2222a6d42e7dSPeter Dunlap 		/*
2223a6d42e7dSPeter Dunlap 		 * STMF doesn't currently support the "abort task" task
2224a6d42e7dSPeter Dunlap 		 * management command although it does support aborting
2225a6d42e7dSPeter Dunlap 		 * an individual task.  We'll get STMF to abort the task
2226a6d42e7dSPeter Dunlap 		 * for us but handle the details of the task management
2227a6d42e7dSPeter Dunlap 		 * command ourselves.
2228a6d42e7dSPeter Dunlap 		 *
2229a6d42e7dSPeter Dunlap 		 * Find the task associated with the referenced task tag.
2230a6d42e7dSPeter Dunlap 		 */
2231a6d42e7dSPeter Dunlap 		rtt = iscsi_tm->rtt;
2232a6d42e7dSPeter Dunlap 		itask = (iscsit_task_t *)idm_task_find_by_handle(ict->ict_ic,
2233a6d42e7dSPeter Dunlap 		    (uintptr_t)rtt);
2234a6d42e7dSPeter Dunlap 
2235a6d42e7dSPeter Dunlap 		if (itask == NULL) {
2236a6d42e7dSPeter Dunlap 			cmdsn = ntohl(iscsi_tm->cmdsn);
2237a6d42e7dSPeter Dunlap 			refcmdsn = ntohl(iscsi_tm->refcmdsn);
2238a6d42e7dSPeter Dunlap 
2239a6d42e7dSPeter Dunlap 			/*
2240a6d42e7dSPeter Dunlap 			 * Task was not found.  If RefCmdSN is within the CmdSN
2241a6d42e7dSPeter Dunlap 			 * window and less than CmdSN of the TM function, return
2242a6d42e7dSPeter Dunlap 			 * "Function Complete".  Otherwise, return
2243a6d42e7dSPeter Dunlap 			 * "Task Does Not Exist".
2244a6d42e7dSPeter Dunlap 			 */
2245a6d42e7dSPeter Dunlap 
2246a6d42e7dSPeter Dunlap 			if (iscsit_cmdsn_in_window(ict, refcmdsn) &&
2247a6d42e7dSPeter Dunlap 			    (refcmdsn < cmdsn)) {
2248a6d42e7dSPeter Dunlap 				iscsit_send_task_mgmt_resp(tm_resp_pdu,
2249a6d42e7dSPeter Dunlap 				    SCSI_TCP_TM_RESP_COMPLETE);
2250a6d42e7dSPeter Dunlap 			} else {
2251a6d42e7dSPeter Dunlap 				iscsit_send_task_mgmt_resp(tm_resp_pdu,
2252a6d42e7dSPeter Dunlap 				    SCSI_TCP_TM_RESP_NO_TASK);
2253a6d42e7dSPeter Dunlap 			}
2254a6d42e7dSPeter Dunlap 		} else {
2255a6d42e7dSPeter Dunlap 
2256a6d42e7dSPeter Dunlap 			/*
2257a6d42e7dSPeter Dunlap 			 * Tell STMF to abort the task.  This will do no harm
2258a6d42e7dSPeter Dunlap 			 * if the task is already complete.
2259a6d42e7dSPeter Dunlap 			 */
2260a6d42e7dSPeter Dunlap 			stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task,
2261a6d42e7dSPeter Dunlap 			    STMF_ABORTED, NULL);
2262a6d42e7dSPeter Dunlap 
2263a6d42e7dSPeter Dunlap 			/*
2264a6d42e7dSPeter Dunlap 			 * Make sure the task hasn't already completed
2265a6d42e7dSPeter Dunlap 			 */
2266a6d42e7dSPeter Dunlap 			mutex_enter(&itask->it_idm_task->idt_mutex);
2267a6d42e7dSPeter Dunlap 			if ((itask->it_idm_task->idt_state == TASK_COMPLETE) ||
2268a6d42e7dSPeter Dunlap 			    (itask->it_idm_task->idt_state == TASK_IDLE)) {
2269a6d42e7dSPeter Dunlap 				/*
2270a6d42e7dSPeter Dunlap 				 * Task is complete, return "Task Does Not
2271a6d42e7dSPeter Dunlap 				 * Exist"
2272a6d42e7dSPeter Dunlap 				 */
2273a6d42e7dSPeter Dunlap 				mutex_exit(&itask->it_idm_task->idt_mutex);
2274a6d42e7dSPeter Dunlap 				iscsit_send_task_mgmt_resp(tm_resp_pdu,
2275a6d42e7dSPeter Dunlap 				    SCSI_TCP_TM_RESP_NO_TASK);
2276a6d42e7dSPeter Dunlap 			} else {
2277a6d42e7dSPeter Dunlap 				/*
2278a6d42e7dSPeter Dunlap 				 * STMF is now aborting the task, return
2279a6d42e7dSPeter Dunlap 				 * "Function Complete"
2280a6d42e7dSPeter Dunlap 				 */
2281a6d42e7dSPeter Dunlap 				mutex_exit(&itask->it_idm_task->idt_mutex);
2282a6d42e7dSPeter Dunlap 				iscsit_send_task_mgmt_resp(tm_resp_pdu,
2283a6d42e7dSPeter Dunlap 				    SCSI_TCP_TM_RESP_COMPLETE);
2284a6d42e7dSPeter Dunlap 			}
2285a6d42e7dSPeter Dunlap 			idm_task_rele(itask->it_idm_task);
2286a6d42e7dSPeter Dunlap 		}
2287a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2288a6d42e7dSPeter Dunlap 		return;
2289a6d42e7dSPeter Dunlap 
2290a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_ABORT_TASK_SET:
2291a6d42e7dSPeter Dunlap 		tm_func = TM_ABORT_TASK_SET;
2292a6d42e7dSPeter Dunlap 		break;
2293a6d42e7dSPeter Dunlap 
2294a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_CLEAR_ACA:
2295a6d42e7dSPeter Dunlap 		tm_func = TM_CLEAR_ACA;
2296a6d42e7dSPeter Dunlap 		break;
2297a6d42e7dSPeter Dunlap 
2298a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_CLEAR_TASK_SET:
2299a6d42e7dSPeter Dunlap 		tm_func = TM_CLEAR_TASK_SET;
2300a6d42e7dSPeter Dunlap 		break;
2301a6d42e7dSPeter Dunlap 
2302a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
2303a6d42e7dSPeter Dunlap 		tm_func = TM_LUN_RESET;
2304a6d42e7dSPeter Dunlap 		break;
2305a6d42e7dSPeter Dunlap 
2306a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_TARGET_WARM_RESET:
2307a6d42e7dSPeter Dunlap 		tm_func = TM_TARGET_WARM_RESET;
2308a6d42e7dSPeter Dunlap 		break;
2309a6d42e7dSPeter Dunlap 
2310a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_TARGET_COLD_RESET:
2311a6d42e7dSPeter Dunlap 		tm_func = TM_TARGET_COLD_RESET;
2312a6d42e7dSPeter Dunlap 		break;
2313a6d42e7dSPeter Dunlap 
2314a6d42e7dSPeter Dunlap 	case ISCSI_TM_FUNC_TASK_REASSIGN:
2315a6d42e7dSPeter Dunlap 		/*
2316a6d42e7dSPeter Dunlap 		 * We do not currently support allegiance reassignment.  When
2317a6d42e7dSPeter Dunlap 		 * we start supporting ERL1+, we will need to.
2318a6d42e7dSPeter Dunlap 		 */
2319a6d42e7dSPeter Dunlap 		iscsit_send_task_mgmt_resp(tm_resp_pdu,
2320a6d42e7dSPeter Dunlap 		    SCSI_TCP_TM_RESP_NO_ALLG_REASSN);
2321a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2322a6d42e7dSPeter Dunlap 		return;
2323a6d42e7dSPeter Dunlap 
2324a6d42e7dSPeter Dunlap 	default:
2325a6d42e7dSPeter Dunlap 		iscsit_send_task_mgmt_resp(tm_resp_pdu,
2326a6d42e7dSPeter Dunlap 		    SCSI_TCP_TM_RESP_REJECTED);
2327a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2328a6d42e7dSPeter Dunlap 		return;
2329a6d42e7dSPeter Dunlap 	}
2330a6d42e7dSPeter Dunlap 
2331a6d42e7dSPeter Dunlap 	tm_itask = iscsit_tm_task_alloc(ict);
2332a6d42e7dSPeter Dunlap 	if (tm_itask == NULL) {
2333a6d42e7dSPeter Dunlap 		iscsit_send_task_mgmt_resp(tm_resp_pdu,
2334a6d42e7dSPeter Dunlap 		    SCSI_TCP_TM_RESP_REJECTED);
2335a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2336a6d42e7dSPeter Dunlap 		return;
2337a6d42e7dSPeter Dunlap 	}
2338a6d42e7dSPeter Dunlap 
2339a6d42e7dSPeter Dunlap 
2340a6d42e7dSPeter Dunlap 	task = stmf_task_alloc(ict->ict_sess->ist_lport,
2341a6d42e7dSPeter Dunlap 	    ict->ict_sess->ist_stmf_sess, iscsi_tm->lun,
2342a6d42e7dSPeter Dunlap 	    0, STMF_TASK_EXT_NONE);
2343a6d42e7dSPeter Dunlap 	if (task == NULL) {
2344a6d42e7dSPeter Dunlap 		/*
2345a6d42e7dSPeter Dunlap 		 * If this happens, either the LU is in reset, couldn't
2346a6d42e7dSPeter Dunlap 		 * get memory, or some other condition in which we simply
2347a6d42e7dSPeter Dunlap 		 * can't complete this request.  It would be nice to return
2348a6d42e7dSPeter Dunlap 		 * an error code like "busy" but the closest we have is
2349a6d42e7dSPeter Dunlap 		 * "rejected".
2350a6d42e7dSPeter Dunlap 		 */
2351a6d42e7dSPeter Dunlap 		iscsit_send_task_mgmt_resp(tm_resp_pdu,
2352a6d42e7dSPeter Dunlap 		    SCSI_TCP_TM_RESP_REJECTED);
2353a6d42e7dSPeter Dunlap 		iscsit_tm_task_free(tm_itask);
2354a6d42e7dSPeter Dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2355a6d42e7dSPeter Dunlap 		return;
2356a6d42e7dSPeter Dunlap 	}
2357a6d42e7dSPeter Dunlap 
2358a6d42e7dSPeter Dunlap 	tm_itask->it_tm_pdu = tm_resp_pdu;
2359a6d42e7dSPeter Dunlap 	tm_itask->it_stmf_task = task;
2360a6d42e7dSPeter Dunlap 	task->task_port_private = tm_itask;
2361a6d42e7dSPeter Dunlap 	task->task_mgmt_function = tm_func;
2362a6d42e7dSPeter Dunlap 	task->task_additional_flags = TASK_AF_NO_EXPECTED_XFER_LENGTH;
2363a6d42e7dSPeter Dunlap 	task->task_priority = 0;
2364a6d42e7dSPeter Dunlap 	task->task_max_nbufs = STMF_BUFS_MAX;
2365a6d42e7dSPeter Dunlap 	task->task_cmd_seq_no = iscsi_tm->itt;
2366a6d42e7dSPeter Dunlap 	task->task_expected_xfer_length = 0;
2367a6d42e7dSPeter Dunlap 
2368a6d42e7dSPeter Dunlap 	stmf_post_task(task, NULL);
2369a6d42e7dSPeter Dunlap 	idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2370a6d42e7dSPeter Dunlap }
2371a6d42e7dSPeter Dunlap 
2372a6d42e7dSPeter Dunlap static void
2373a6d42e7dSPeter Dunlap iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2374a6d42e7dSPeter Dunlap {
2375a6d42e7dSPeter Dunlap 	iscsi_nop_out_hdr_t *out = (iscsi_nop_out_hdr_t *)rx_pdu->isp_hdr;
2376a6d42e7dSPeter Dunlap 	iscsi_nop_in_hdr_t *in;
2377a6d42e7dSPeter Dunlap 	int resp_datalen;
2378a6d42e7dSPeter Dunlap 	idm_pdu_t *resp;
2379a6d42e7dSPeter Dunlap 
2380a6d42e7dSPeter Dunlap 	/* Ignore the response from initiator */
238172cf3143Speter dunlap 	if ((out->itt == ISCSI_RSVD_TASK_TAG) ||
238272cf3143Speter dunlap 	    (out->ttt != ISCSI_RSVD_TASK_TAG)) {
238372cf3143Speter dunlap 		idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2384a6d42e7dSPeter Dunlap 		return;
238572cf3143Speter dunlap 	}
2386a6d42e7dSPeter Dunlap 
2387a6d42e7dSPeter Dunlap 	/* Allocate a PDU to respond */
2388a6d42e7dSPeter Dunlap 	resp_datalen = ntoh24(out->dlength);
2389a6d42e7dSPeter Dunlap 	resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen);
2390a6d42e7dSPeter Dunlap 	idm_pdu_init(resp, ict->ict_ic, NULL, NULL);
2391a6d42e7dSPeter Dunlap 	if (resp_datalen > 0) {
2392a6d42e7dSPeter Dunlap 		bcopy(rx_pdu->isp_data, resp->isp_data, resp_datalen);
2393a6d42e7dSPeter Dunlap 	}
2394a6d42e7dSPeter Dunlap 
239560220f10SPriya Krishnan 	/*
239660220f10SPriya Krishnan 	 * When sending a NOP-In as a response to a NOP-Out from the initiator,
239760220f10SPriya Krishnan 	 * the target must respond with the same initiator task tag that was
239860220f10SPriya Krishnan 	 * provided in the NOP-Out request, the target transfer tag must be
239960220f10SPriya Krishnan 	 * ISCSI_RSVD_TASK_TAG (0xffffffff) and StatSN will contain the next
240060220f10SPriya Krishnan 	 * status sequence number. The StatSN for the connection is advanced
240160220f10SPriya Krishnan 	 * after this PDU is sent.
240260220f10SPriya Krishnan 	 */
2403a6d42e7dSPeter Dunlap 	in = (iscsi_nop_in_hdr_t *)resp->isp_hdr;
2404a6d42e7dSPeter Dunlap 	bzero(in, sizeof (*in));
2405a6d42e7dSPeter Dunlap 	in->opcode = ISCSI_OP_NOOP_IN;
2406a6d42e7dSPeter Dunlap 	in->flags = ISCSI_FLAG_FINAL;
2407a6d42e7dSPeter Dunlap 	bcopy(out->lun, in->lun, 8);
2408a6d42e7dSPeter Dunlap 	in->itt		= out->itt;
2409a6d42e7dSPeter Dunlap 	in->ttt		= ISCSI_RSVD_TASK_TAG;
2410a6d42e7dSPeter Dunlap 	hton24(in->dlength, resp_datalen);
241160220f10SPriya Krishnan 	resp->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2412a6d42e7dSPeter Dunlap 	/* Any other field in resp to be set? */
2413a6d42e7dSPeter Dunlap 	iscsit_pdu_tx(resp);
2414a6d42e7dSPeter Dunlap 	idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2415a6d42e7dSPeter Dunlap }
2416a6d42e7dSPeter Dunlap 
2417a6d42e7dSPeter Dunlap static void
2418a6d42e7dSPeter Dunlap iscsit_pdu_op_login_cmd(iscsit_conn_t	*ict, idm_pdu_t *rx_pdu)
2419a6d42e7dSPeter Dunlap {
2420a6d42e7dSPeter Dunlap 
2421a6d42e7dSPeter Dunlap 	/*
2422a6d42e7dSPeter Dunlap 	 * Submit PDU to login state machine.  State machine will free the
2423a6d42e7dSPeter Dunlap 	 * PDU.
2424a6d42e7dSPeter Dunlap 	 */
2425a6d42e7dSPeter Dunlap 	iscsit_login_sm_event(ict, ILE_LOGIN_RCV, rx_pdu);
2426a6d42e7dSPeter Dunlap }
2427a6d42e7dSPeter Dunlap 
2428a6d42e7dSPeter Dunlap void
2429a6d42e7dSPeter Dunlap iscsit_pdu_op_logout_cmd(iscsit_conn_t	*ict, idm_pdu_t *rx_pdu)
2430a6d42e7dSPeter Dunlap {
2431a6d42e7dSPeter Dunlap 	iscsi_logout_hdr_t 	*logout_req =
2432a6d42e7dSPeter Dunlap 	    (iscsi_logout_hdr_t *)rx_pdu->isp_hdr;
2433a6d42e7dSPeter Dunlap 	iscsi_logout_rsp_hdr_t	*logout_rsp;
2434a6d42e7dSPeter Dunlap 	idm_pdu_t *resp;
2435a6d42e7dSPeter Dunlap 
2436a6d42e7dSPeter Dunlap 	/* Allocate a PDU to respond */
2437a6d42e7dSPeter Dunlap 	resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
2438a6d42e7dSPeter Dunlap 	idm_pdu_init(resp, ict->ict_ic, NULL, NULL);
243960220f10SPriya Krishnan 	/*
244060220f10SPriya Krishnan 	 * The StatSN is to be sent to the initiator,
244160220f10SPriya Krishnan 	 * it is not required to increment the number
244260220f10SPriya Krishnan 	 * as the connection is terminating.
244360220f10SPriya Krishnan 	 */
244460220f10SPriya Krishnan 	resp->isp_flags |= IDM_PDU_SET_STATSN;
2445a6d42e7dSPeter Dunlap 	/*
2446a6d42e7dSPeter Dunlap 	 * Logout results in the immediate termination of all tasks except
2447a6d42e7dSPeter Dunlap 	 * if the logout reason is ISCSI_LOGOUT_REASON_RECOVERY.  The
2448a6d42e7dSPeter Dunlap 	 * connection state machine will drive this task cleanup automatically
2449a6d42e7dSPeter Dunlap 	 * so we don't need to handle that here.
2450a6d42e7dSPeter Dunlap 	 */
2451a6d42e7dSPeter Dunlap 	logout_rsp = (iscsi_logout_rsp_hdr_t *)resp->isp_hdr;
2452a6d42e7dSPeter Dunlap 	bzero(logout_rsp, sizeof (*logout_rsp));
2453a6d42e7dSPeter Dunlap 	logout_rsp->opcode = ISCSI_OP_LOGOUT_RSP;
2454a6d42e7dSPeter Dunlap 	logout_rsp->flags = ISCSI_FLAG_FINAL;
2455a6d42e7dSPeter Dunlap 	logout_rsp->itt = logout_req->itt;
2456a6d42e7dSPeter Dunlap 	if ((logout_req->flags & ISCSI_FLAG_LOGOUT_REASON_MASK) >
2457a6d42e7dSPeter Dunlap 	    ISCSI_LOGOUT_REASON_RECOVERY) {
2458a6d42e7dSPeter Dunlap 		logout_rsp->response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED;
2459a6d42e7dSPeter Dunlap 	} else {
2460a6d42e7dSPeter Dunlap 		logout_rsp->response = ISCSI_LOGOUT_SUCCESS;
2461a6d42e7dSPeter Dunlap 	}
2462a6d42e7dSPeter Dunlap 
2463a6d42e7dSPeter Dunlap 	iscsit_pdu_tx(resp);
2464a6d42e7dSPeter Dunlap 	idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS);
2465a6d42e7dSPeter Dunlap }
2466a6d42e7dSPeter Dunlap 
2467a6d42e7dSPeter Dunlap /*
2468a6d42e7dSPeter Dunlap  * Calculate the number of outstanding commands we can process
2469a6d42e7dSPeter Dunlap  */
2470a6d42e7dSPeter Dunlap int
2471a6d42e7dSPeter Dunlap iscsit_cmd_window()
2472a6d42e7dSPeter Dunlap {
2473a6d42e7dSPeter Dunlap 	/* Will be better later */
2474a6d42e7dSPeter Dunlap 	return	(1024);
2475a6d42e7dSPeter Dunlap }
2476a6d42e7dSPeter Dunlap 
2477a6d42e7dSPeter Dunlap /*
2478a6d42e7dSPeter Dunlap  * Set local registers based on incoming PDU
2479a6d42e7dSPeter Dunlap  */
2480a6d42e7dSPeter Dunlap void
2481a6d42e7dSPeter Dunlap iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu)
2482a6d42e7dSPeter Dunlap {
2483a6d42e7dSPeter Dunlap 	iscsit_sess_t *ist;
2484a6d42e7dSPeter Dunlap 	iscsi_scsi_cmd_hdr_t *req;
2485a6d42e7dSPeter Dunlap 
2486a6d42e7dSPeter Dunlap 	ist = ict->ict_sess;
2487a6d42e7dSPeter Dunlap 
2488a6d42e7dSPeter Dunlap 	req = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr;
2489a6d42e7dSPeter Dunlap 
2490a6d42e7dSPeter Dunlap 	rw_enter(&ist->ist_sn_rwlock, RW_WRITER);
2491a6d42e7dSPeter Dunlap 	ist->ist_expcmdsn = ntohl(req->cmdsn) + 1;
2492a6d42e7dSPeter Dunlap 	ist->ist_maxcmdsn = ntohl(req->cmdsn) + iscsit_cmd_window();
2493a6d42e7dSPeter Dunlap 	rw_exit(&ist->ist_sn_rwlock);
2494a6d42e7dSPeter Dunlap }
2495a6d42e7dSPeter Dunlap 
2496a6d42e7dSPeter Dunlap /*
2497a6d42e7dSPeter Dunlap  * Wrapper funtion, calls iscsi_calc_rspsn and idm_pdu_tx
2498a6d42e7dSPeter Dunlap  */
2499a6d42e7dSPeter Dunlap void
2500a6d42e7dSPeter Dunlap iscsit_pdu_tx(idm_pdu_t *pdu)
2501a6d42e7dSPeter Dunlap {
2502a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = pdu->isp_ic->ic_handle;
250360220f10SPriya Krishnan 	iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
250460220f10SPriya Krishnan 	iscsit_sess_t *ist = ict->ict_sess;
2505a6d42e7dSPeter Dunlap 
2506a6d42e7dSPeter Dunlap 	/*
250760220f10SPriya Krishnan 	 * The command sequence numbers are session-wide and must stay
250860220f10SPriya Krishnan 	 * consistent across the transfer, so protect the cmdsn with a
250960220f10SPriya Krishnan 	 * reader lock on the session. The status sequence number will
251060220f10SPriya Krishnan 	 * be updated just before the transport layer transmits the PDU.
2511a6d42e7dSPeter Dunlap 	 */
251260220f10SPriya Krishnan 
251360220f10SPriya Krishnan 	rw_enter(&ict->ict_sess->ist_sn_rwlock, RW_READER);
251460220f10SPriya Krishnan 	/* Set ExpCmdSN and MaxCmdSN */
251560220f10SPriya Krishnan 	rsp->maxcmdsn = htonl(ist->ist_maxcmdsn);
251660220f10SPriya Krishnan 	rsp->expcmdsn = htonl(ist->ist_expcmdsn);
2517a6d42e7dSPeter Dunlap 	idm_pdu_tx(pdu);
2518a6d42e7dSPeter Dunlap 	rw_exit(&ict->ict_sess->ist_sn_rwlock);
2519a6d42e7dSPeter Dunlap }
2520a6d42e7dSPeter Dunlap 
2521a6d42e7dSPeter Dunlap /*
2522a6d42e7dSPeter Dunlap  * Internal functions
2523a6d42e7dSPeter Dunlap  */
2524a6d42e7dSPeter Dunlap 
2525a6d42e7dSPeter Dunlap void
2526a6d42e7dSPeter Dunlap iscsit_send_async_event(iscsit_conn_t *ict, uint8_t event)
2527a6d42e7dSPeter Dunlap {
2528a6d42e7dSPeter Dunlap 	idm_pdu_t		*abt;
2529a6d42e7dSPeter Dunlap 	iscsi_async_evt_hdr_t	*async_abt;
2530a6d42e7dSPeter Dunlap 
2531a6d42e7dSPeter Dunlap 	/*
2532a6d42e7dSPeter Dunlap 	 * Get a PDU to build the abort request.
2533a6d42e7dSPeter Dunlap 	 */
2534a6d42e7dSPeter Dunlap 	abt = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
2535a6d42e7dSPeter Dunlap 	if (abt == NULL) {
2536a6d42e7dSPeter Dunlap 		idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL);
2537a6d42e7dSPeter Dunlap 		return;
2538a6d42e7dSPeter Dunlap 	}
2539a6d42e7dSPeter Dunlap 
254060220f10SPriya Krishnan 	/*
254160220f10SPriya Krishnan 	 * A asynchronous message is sent by the target to request a logout.
254260220f10SPriya Krishnan 	 * The StatSN for the connection is advanced after the PDU is sent
254360220f10SPriya Krishnan 	 * to allow for initiator and target state synchronization.
254460220f10SPriya Krishnan 	 */
254572cf3143Speter dunlap 	idm_pdu_init(abt, ict->ict_ic, NULL, NULL);
2546a6d42e7dSPeter Dunlap 	abt->isp_datalen = 0;
254760220f10SPriya Krishnan 	abt->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
2548a6d42e7dSPeter Dunlap 
2549a6d42e7dSPeter Dunlap 	async_abt = (iscsi_async_evt_hdr_t *)abt->isp_hdr;
2550a6d42e7dSPeter Dunlap 	bzero(async_abt, sizeof (*async_abt));
2551a6d42e7dSPeter Dunlap 	async_abt->opcode = ISCSI_OP_ASYNC_EVENT;
2552a6d42e7dSPeter Dunlap 	async_abt->async_event = event;
2553a6d42e7dSPeter Dunlap 	async_abt->flags = ISCSI_FLAG_FINAL;
2554a6d42e7dSPeter Dunlap 	async_abt->rsvd4[0] = 0xff;
2555a6d42e7dSPeter Dunlap 	async_abt->rsvd4[1] = 0xff;
2556a6d42e7dSPeter Dunlap 	async_abt->rsvd4[2] = 0xff;
2557a6d42e7dSPeter Dunlap 	async_abt->rsvd4[3] = 0xff;
2558a6d42e7dSPeter Dunlap 
2559a6d42e7dSPeter Dunlap 	switch (event) {
2560a6d42e7dSPeter Dunlap 	case ISCSI_ASYNC_EVENT_REQUEST_LOGOUT:
2561a6d42e7dSPeter Dunlap 		async_abt->param3 = htons(IDM_LOGOUT_SECONDS);
2562a6d42e7dSPeter Dunlap 		break;
2563a6d42e7dSPeter Dunlap 	case ISCSI_ASYNC_EVENT_SCSI_EVENT:
2564a6d42e7dSPeter Dunlap 	case ISCSI_ASYNC_EVENT_DROPPING_CONNECTION:
2565a6d42e7dSPeter Dunlap 	case ISCSI_ASYNC_EVENT_DROPPING_ALL_CONNECTIONS:
2566a6d42e7dSPeter Dunlap 	case ISCSI_ASYNC_EVENT_PARAM_NEGOTIATION:
2567a6d42e7dSPeter Dunlap 	default:
2568a6d42e7dSPeter Dunlap 		ASSERT(0);
2569a6d42e7dSPeter Dunlap 	}
2570a6d42e7dSPeter Dunlap 
2571a6d42e7dSPeter Dunlap 	iscsit_pdu_tx(abt);
2572a6d42e7dSPeter Dunlap }
2573a6d42e7dSPeter Dunlap 
257472cf3143Speter dunlap void
257572cf3143Speter dunlap iscsit_send_reject(iscsit_conn_t *ict, idm_pdu_t *rejected_pdu, uint8_t reason)
257672cf3143Speter dunlap {
257772cf3143Speter dunlap 	idm_pdu_t		*reject_pdu;
257872cf3143Speter dunlap 	iscsi_reject_rsp_hdr_t	*reject;
257972cf3143Speter dunlap 
258072cf3143Speter dunlap 	/*
258172cf3143Speter dunlap 	 * Get a PDU to build the abort request.
258272cf3143Speter dunlap 	 */
258372cf3143Speter dunlap 	reject_pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t),
258472cf3143Speter dunlap 	    rejected_pdu->isp_hdrlen);
258572cf3143Speter dunlap 	if (reject_pdu == NULL) {
258672cf3143Speter dunlap 		idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL);
258772cf3143Speter dunlap 		return;
258872cf3143Speter dunlap 	}
258972cf3143Speter dunlap 	idm_pdu_init(reject_pdu, ict->ict_ic, NULL, NULL);
259060220f10SPriya Krishnan 	/* StatSN is advanced after a Reject PDU */
259160220f10SPriya Krishnan 	reject_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
259272cf3143Speter dunlap 	reject_pdu->isp_datalen = rejected_pdu->isp_hdrlen;
259372cf3143Speter dunlap 	bcopy(rejected_pdu->isp_hdr, reject_pdu->isp_data,
259472cf3143Speter dunlap 	    rejected_pdu->isp_hdrlen);
259572cf3143Speter dunlap 
259672cf3143Speter dunlap 	reject = (iscsi_reject_rsp_hdr_t *)reject_pdu->isp_hdr;
259772cf3143Speter dunlap 	bzero(reject, sizeof (*reject));
259872cf3143Speter dunlap 	reject->opcode = ISCSI_OP_REJECT_MSG;
259972cf3143Speter dunlap 	reject->reason = reason;
260072cf3143Speter dunlap 	reject->flags = ISCSI_FLAG_FINAL;
260172cf3143Speter dunlap 	hton24(reject->dlength, rejected_pdu->isp_hdrlen);
260272cf3143Speter dunlap 	reject->must_be_ff[0] = 0xff;
260372cf3143Speter dunlap 	reject->must_be_ff[1] = 0xff;
260472cf3143Speter dunlap 	reject->must_be_ff[2] = 0xff;
260572cf3143Speter dunlap 	reject->must_be_ff[3] = 0xff;
260672cf3143Speter dunlap 
260772cf3143Speter dunlap 	iscsit_pdu_tx(reject_pdu);
260872cf3143Speter dunlap }
260972cf3143Speter dunlap 
2610a6d42e7dSPeter Dunlap 
2611a6d42e7dSPeter Dunlap static iscsit_task_t *
2612a6d42e7dSPeter Dunlap iscsit_task_alloc(iscsit_conn_t *ict)
2613a6d42e7dSPeter Dunlap {
2614a6d42e7dSPeter Dunlap 	iscsit_task_t *itask;
2615a6d42e7dSPeter Dunlap 	iscsit_buf_t *immed_ibuf;
2616a6d42e7dSPeter Dunlap 
2617a6d42e7dSPeter Dunlap 	/*
2618a6d42e7dSPeter Dunlap 	 * Possible items to pre-alloc if we cache iscsit_task_t's:
2619a6d42e7dSPeter Dunlap 	 *
2620a6d42e7dSPeter Dunlap 	 * Status PDU w/ sense buffer
2621a6d42e7dSPeter Dunlap 	 * stmf_data_buf_t for immediate data
2622a6d42e7dSPeter Dunlap 	 */
2623a6d42e7dSPeter Dunlap 	itask = kmem_alloc(sizeof (iscsit_task_t) + sizeof (iscsit_buf_t) +
2624a6d42e7dSPeter Dunlap 	    sizeof (stmf_data_buf_t), KM_NOSLEEP);
2625a6d42e7dSPeter Dunlap 	if (itask != NULL) {
2626a6d42e7dSPeter Dunlap 		mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL);
2627a6d42e7dSPeter Dunlap 		itask->it_aborted = itask->it_stmf_abort =
2628a6d42e7dSPeter Dunlap 		    itask->it_tm_task = 0;
2629a6d42e7dSPeter Dunlap 
2630a6d42e7dSPeter Dunlap 		immed_ibuf = (iscsit_buf_t *)(itask + 1);
2631a6d42e7dSPeter Dunlap 		bzero(immed_ibuf, sizeof (*immed_ibuf));
2632a6d42e7dSPeter Dunlap 		immed_ibuf->ibuf_is_immed = B_TRUE;
2633a6d42e7dSPeter Dunlap 		immed_ibuf->ibuf_stmf_buf = (stmf_data_buf_t *)(immed_ibuf + 1);
2634a6d42e7dSPeter Dunlap 
2635a6d42e7dSPeter Dunlap 		bzero(immed_ibuf->ibuf_stmf_buf, sizeof (stmf_data_buf_t));
2636a6d42e7dSPeter Dunlap 		immed_ibuf->ibuf_stmf_buf->db_port_private = immed_ibuf;
2637a6d42e7dSPeter Dunlap 		immed_ibuf->ibuf_stmf_buf->db_sglist_length = 1;
2638a6d42e7dSPeter Dunlap 		immed_ibuf->ibuf_stmf_buf->db_flags = DB_DIRECTION_FROM_RPORT |
2639a6d42e7dSPeter Dunlap 		    DB_DONT_CACHE;
2640a6d42e7dSPeter Dunlap 		itask->it_immed_data = immed_ibuf;
2641a6d42e7dSPeter Dunlap 		itask->it_idm_task = idm_task_alloc(ict->ict_ic);
2642a6d42e7dSPeter Dunlap 		if (itask->it_idm_task != NULL) {
2643a6d42e7dSPeter Dunlap 			itask->it_idm_task->idt_private = itask;
2644a6d42e7dSPeter Dunlap 			itask->it_ict = ict;
2645a6d42e7dSPeter Dunlap 			itask->it_ttt = itask->it_idm_task->idt_tt;
2646a6d42e7dSPeter Dunlap 			return (itask);
2647a6d42e7dSPeter Dunlap 		} else {
2648a6d42e7dSPeter Dunlap 			kmem_free(itask, sizeof (iscsit_task_t) +
2649a6d42e7dSPeter Dunlap 			    sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t));
2650a6d42e7dSPeter Dunlap 		}
2651a6d42e7dSPeter Dunlap 	}
2652a6d42e7dSPeter Dunlap 
2653a6d42e7dSPeter Dunlap 	return (NULL);
2654a6d42e7dSPeter Dunlap }
2655a6d42e7dSPeter Dunlap 
2656a6d42e7dSPeter Dunlap static void
2657a6d42e7dSPeter Dunlap iscsit_task_free(iscsit_task_t *itask)
2658a6d42e7dSPeter Dunlap {
2659a6d42e7dSPeter Dunlap 	idm_task_free(itask->it_idm_task);
2660a6d42e7dSPeter Dunlap 	mutex_destroy(&itask->it_mutex);
2661a6d42e7dSPeter Dunlap 	kmem_free(itask, sizeof (iscsit_task_t) +
2662a6d42e7dSPeter Dunlap 	    sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t));
2663a6d42e7dSPeter Dunlap }
2664a6d42e7dSPeter Dunlap 
2665a6d42e7dSPeter Dunlap static iscsit_task_t *
2666a6d42e7dSPeter Dunlap iscsit_tm_task_alloc(iscsit_conn_t *ict)
2667a6d42e7dSPeter Dunlap {
2668a6d42e7dSPeter Dunlap 	iscsit_task_t *itask;
2669a6d42e7dSPeter Dunlap 
2670a6d42e7dSPeter Dunlap 	itask = kmem_zalloc(sizeof (iscsit_task_t), KM_NOSLEEP);
2671a6d42e7dSPeter Dunlap 	if (itask != NULL) {
2672a6d42e7dSPeter Dunlap 		idm_conn_hold(ict->ict_ic);
2673a6d42e7dSPeter Dunlap 		mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL);
2674a6d42e7dSPeter Dunlap 		itask->it_aborted = itask->it_stmf_abort =
2675a6d42e7dSPeter Dunlap 		    itask->it_tm_responded = 0;
2676a6d42e7dSPeter Dunlap 		itask->it_tm_pdu = NULL;
2677a6d42e7dSPeter Dunlap 		itask->it_tm_task = 1;
2678a6d42e7dSPeter Dunlap 		itask->it_ict = ict;
2679a6d42e7dSPeter Dunlap 	}
2680a6d42e7dSPeter Dunlap 
2681a6d42e7dSPeter Dunlap 	return (itask);
2682a6d42e7dSPeter Dunlap }
2683a6d42e7dSPeter Dunlap 
2684a6d42e7dSPeter Dunlap static void
2685a6d42e7dSPeter Dunlap iscsit_tm_task_free(iscsit_task_t *itask)
2686a6d42e7dSPeter Dunlap {
2687a6d42e7dSPeter Dunlap 	/*
2688a6d42e7dSPeter Dunlap 	 * If we responded then the call to idm_pdu_complete will free the
2689a6d42e7dSPeter Dunlap 	 * PDU.  Otherwise we got aborted before the TM function could
2690a6d42e7dSPeter Dunlap 	 * complete and we need to free the PDU explicitly.
2691a6d42e7dSPeter Dunlap 	 */
2692a6d42e7dSPeter Dunlap 	if (itask->it_tm_pdu != NULL && !itask->it_tm_responded)
2693a6d42e7dSPeter Dunlap 		idm_pdu_free(itask->it_tm_pdu);
2694a6d42e7dSPeter Dunlap 	idm_conn_rele(itask->it_ict->ict_ic);
2695a6d42e7dSPeter Dunlap 	mutex_destroy(&itask->it_mutex);
2696a6d42e7dSPeter Dunlap 	kmem_free(itask, sizeof (iscsit_task_t));
2697a6d42e7dSPeter Dunlap }
2698a6d42e7dSPeter Dunlap 
269972cf3143Speter dunlap static idm_status_t
270072cf3143Speter dunlap iscsit_task_start(iscsit_task_t *itask)
270172cf3143Speter dunlap {
270272cf3143Speter dunlap 	iscsit_sess_t *ist = itask->it_ict->ict_sess;
270372cf3143Speter dunlap 	avl_index_t		where;
270472cf3143Speter dunlap 
270572cf3143Speter dunlap 	/*
270672cf3143Speter dunlap 	 * Sanity check the ITT and ensure that this task does not already
270772cf3143Speter dunlap 	 * exist.  If not then add the task to the session task list.
270872cf3143Speter dunlap 	 */
270972cf3143Speter dunlap 	mutex_enter(&ist->ist_mutex);
271072cf3143Speter dunlap 	mutex_enter(&itask->it_mutex);
271172cf3143Speter dunlap 	itask->it_active = 1;
271272cf3143Speter dunlap 	if (avl_find(&ist->ist_task_list, itask, &where) == NULL) {
271372cf3143Speter dunlap 		/* New task, add to AVL */
271472cf3143Speter dunlap 		avl_insert(&ist->ist_task_list, itask, where);
271572cf3143Speter dunlap 		mutex_exit(&itask->it_mutex);
271672cf3143Speter dunlap 		mutex_exit(&ist->ist_mutex);
271772cf3143Speter dunlap 		return (IDM_STATUS_SUCCESS);
271872cf3143Speter dunlap 	}
271972cf3143Speter dunlap 	mutex_exit(&itask->it_mutex);
272072cf3143Speter dunlap 	mutex_exit(&ist->ist_mutex);
272172cf3143Speter dunlap 
272272cf3143Speter dunlap 	return (IDM_STATUS_REJECT);
272372cf3143Speter dunlap }
272472cf3143Speter dunlap 
272572cf3143Speter dunlap static void
272672cf3143Speter dunlap iscsit_task_done(iscsit_task_t *itask)
272772cf3143Speter dunlap {
272872cf3143Speter dunlap 	iscsit_sess_t *ist = itask->it_ict->ict_sess;
272972cf3143Speter dunlap 
273072cf3143Speter dunlap 	mutex_enter(&ist->ist_mutex);
273172cf3143Speter dunlap 	mutex_enter(&itask->it_mutex);
273272cf3143Speter dunlap 	if (itask->it_active) {
273372cf3143Speter dunlap 		avl_remove(&ist->ist_task_list, itask);
273472cf3143Speter dunlap 		itask->it_active = 0;
273572cf3143Speter dunlap 	}
273672cf3143Speter dunlap 	mutex_exit(&itask->it_mutex);
273772cf3143Speter dunlap 	mutex_exit(&ist->ist_mutex);
273872cf3143Speter dunlap }
273972cf3143Speter dunlap 
2740a6d42e7dSPeter Dunlap /*
2741a6d42e7dSPeter Dunlap  * iscsit status PDU cache
2742a6d42e7dSPeter Dunlap  */
2743a6d42e7dSPeter Dunlap 
2744a6d42e7dSPeter Dunlap /*ARGSUSED*/
2745a6d42e7dSPeter Dunlap static int
2746a6d42e7dSPeter Dunlap iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags)
2747a6d42e7dSPeter Dunlap {
2748a6d42e7dSPeter Dunlap 	idm_pdu_t *pdu = pdu_void;
2749a6d42e7dSPeter Dunlap 	iscsi_scsi_rsp_hdr_t *rsp;
2750a6d42e7dSPeter Dunlap 
2751a6d42e7dSPeter Dunlap 	bzero(pdu, sizeof (idm_pdu_t));
2752a6d42e7dSPeter Dunlap 	pdu->isp_callback = iscsit_send_good_status_done;
2753a6d42e7dSPeter Dunlap 	pdu->isp_magic = IDM_PDU_MAGIC;
2754a6d42e7dSPeter Dunlap 	pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */
2755a6d42e7dSPeter Dunlap 	pdu->isp_hdrlen = sizeof (iscsi_hdr_t);
2756a6d42e7dSPeter Dunlap 
2757a6d42e7dSPeter Dunlap 	/* Setup status response */
2758a6d42e7dSPeter Dunlap 	rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr;
2759a6d42e7dSPeter Dunlap 	bzero(rsp, sizeof (*rsp));
2760a6d42e7dSPeter Dunlap 	rsp->opcode = ISCSI_OP_SCSI_RSP;
2761a6d42e7dSPeter Dunlap 	rsp->flags = ISCSI_FLAG_FINAL;
2762a6d42e7dSPeter Dunlap 	rsp->response = ISCSI_STATUS_CMD_COMPLETED;
2763a6d42e7dSPeter Dunlap 
2764a6d42e7dSPeter Dunlap 	return (0);
2765a6d42e7dSPeter Dunlap }
2766a6d42e7dSPeter Dunlap 
2767a6d42e7dSPeter Dunlap /*
2768a6d42e7dSPeter Dunlap  * iscsit private data handler
2769a6d42e7dSPeter Dunlap  */
2770a6d42e7dSPeter Dunlap 
2771a6d42e7dSPeter Dunlap /*ARGSUSED*/
2772a6d42e7dSPeter Dunlap static void
2773a6d42e7dSPeter Dunlap iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags)
2774a6d42e7dSPeter Dunlap {
2775a6d42e7dSPeter Dunlap 	it_config_t		*cfg;
2776a6d42e7dSPeter Dunlap 	nvlist_t		*nvl;
2777*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	iscsit_service_enabled_t	old_state;
2778a6d42e7dSPeter Dunlap 
2779a6d42e7dSPeter Dunlap 	if ((cmd != STMF_PROVIDER_DATA_UPDATED) || (arg == NULL)) {
2780a6d42e7dSPeter Dunlap 		return;
2781a6d42e7dSPeter Dunlap 	}
2782a6d42e7dSPeter Dunlap 
2783a6d42e7dSPeter Dunlap 	nvl = (nvlist_t *)arg;
2784a6d42e7dSPeter Dunlap 
2785a6d42e7dSPeter Dunlap 	/* Translate nvlist */
2786a6d42e7dSPeter Dunlap 	if (it_nv_to_config(nvl, &cfg) != 0) {
2787a6d42e7dSPeter Dunlap 		cmn_err(CE_WARN, "Configuration is invalid");
2788a6d42e7dSPeter Dunlap 		return;
2789a6d42e7dSPeter Dunlap 	}
2790a6d42e7dSPeter Dunlap 
2791*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	/* Check that no iSCSI ioctl is currently running */
2792*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_enter(&iscsit_global.global_state_mutex);
2793*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	old_state = iscsit_global.global_svc_state;
2794*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	switch (iscsit_global.global_svc_state) {
2795*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	case ISE_ENABLED:
2796*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	case ISE_DISABLED:
2797*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		iscsit_global.global_svc_state = ISE_BUSY;
2798*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		break;
2799*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	case ISE_ENABLING:
2800*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		/*
2801*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		 * It is OK for the iscsit_pp_cb to be called from inside of
2802*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		 * an iSCSI ioctl only if we are currently executing inside
2803*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		 * of stmf_register_port_provider.
2804*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		 */
2805*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		ASSERT((flags & STMF_PCB_PREG_COMPLETE) != 0);
2806*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		break;
2807*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	default:
2808*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		cmn_err(CE_WARN, "iscsit_pp_cb called when global_svc_state"
2809*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		    " is not ENABLED(0x%x) -- ignoring",
2810*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		    iscsit_global.global_svc_state);
2811*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		mutex_exit(&iscsit_global.global_state_mutex);
2812*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		it_config_free_cmn(cfg);
2813*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		return;
2814*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
2815*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_exit(&iscsit_global.global_state_mutex);
2816*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2817a6d42e7dSPeter Dunlap 	/* Update config */
2818a6d42e7dSPeter Dunlap 	(void) iscsit_config_merge(cfg);
2819a6d42e7dSPeter Dunlap 
2820a6d42e7dSPeter Dunlap 	it_config_free_cmn(cfg);
2821*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 
2822*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	/* Restore old iSCSI driver global state */
2823*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_enter(&iscsit_global.global_state_mutex);
2824*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	ASSERT(iscsit_global.global_svc_state == ISE_BUSY ||
2825*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	    iscsit_global.global_svc_state == ISE_ENABLING);
2826*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	iscsit_global.global_svc_state = old_state;
2827*8c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	mutex_exit(&iscsit_global.global_state_mutex);
2828a6d42e7dSPeter Dunlap }
2829a6d42e7dSPeter Dunlap 
2830a6d42e7dSPeter Dunlap 
2831a6d42e7dSPeter Dunlap static it_cfg_status_t
2832a6d42e7dSPeter Dunlap iscsit_config_merge(it_config_t *in_cfg)
2833a6d42e7dSPeter Dunlap {
2834a6d42e7dSPeter Dunlap 	it_cfg_status_t	status;
2835a6d42e7dSPeter Dunlap 	it_config_t	*cfg;
2836a6d42e7dSPeter Dunlap 	it_config_t	tmp_cfg;
2837a6d42e7dSPeter Dunlap 	list_t		tpg_del_list;
2838a6d42e7dSPeter Dunlap 
2839a6d42e7dSPeter Dunlap 	if (in_cfg) {
2840a6d42e7dSPeter Dunlap 		cfg = in_cfg;
2841a6d42e7dSPeter Dunlap 	} else {
2842a6d42e7dSPeter Dunlap 		/* Make empty config */
2843a6d42e7dSPeter Dunlap 		bzero(&tmp_cfg, sizeof (tmp_cfg));
2844a6d42e7dSPeter Dunlap 		cfg = &tmp_cfg;
2845a6d42e7dSPeter Dunlap 	}
2846a6d42e7dSPeter Dunlap 
2847a6d42e7dSPeter Dunlap 	list_create(&tpg_del_list,  sizeof (iscsit_tpg_t),
2848a6d42e7dSPeter Dunlap 	    offsetof(iscsit_tpg_t, tpg_delete_ln));
2849a6d42e7dSPeter Dunlap 
2850a6d42e7dSPeter Dunlap 	/*
2851a6d42e7dSPeter Dunlap 	 * Update targets, initiator contexts, target portal groups,
2852a6d42e7dSPeter Dunlap 	 * and iSNS client
2853a6d42e7dSPeter Dunlap 	 */
2854a6d42e7dSPeter Dunlap 	ISCSIT_GLOBAL_LOCK(RW_WRITER);
2855a6d42e7dSPeter Dunlap 	if (((status = iscsit_config_merge_tpg(cfg, &tpg_del_list))
2856a6d42e7dSPeter Dunlap 	    != 0) ||
2857a6d42e7dSPeter Dunlap 	    ((status = iscsit_config_merge_tgt(cfg)) != 0) ||
2858a6d42e7dSPeter Dunlap 	    ((status = iscsit_config_merge_ini(cfg)) != 0) ||
2859a6d42e7dSPeter Dunlap 	    ((status = isnst_config_merge(cfg)) != 0)) {
2860a6d42e7dSPeter Dunlap 		ISCSIT_GLOBAL_UNLOCK();
2861a6d42e7dSPeter Dunlap 		return (status);
2862a6d42e7dSPeter Dunlap 	}
2863a6d42e7dSPeter Dunlap 
2864a6d42e7dSPeter Dunlap 	/* Update other global config parameters */
2865a6d42e7dSPeter Dunlap 	if (iscsit_global.global_props) {
2866a6d42e7dSPeter Dunlap 		nvlist_free(iscsit_global.global_props);
2867a6d42e7dSPeter Dunlap 		iscsit_global.global_props = NULL;
2868a6d42e7dSPeter Dunlap 	}
2869a6d42e7dSPeter Dunlap 	if (in_cfg) {
2870a6d42e7dSPeter Dunlap 		(void) nvlist_dup(cfg->config_global_properties,
2871a6d42e7dSPeter Dunlap 		    &iscsit_global.global_props, KM_SLEEP);
2872a6d42e7dSPeter Dunlap 	}
2873a6d42e7dSPeter Dunlap 	ISCSIT_GLOBAL_UNLOCK();
2874a6d42e7dSPeter Dunlap 
2875a6d42e7dSPeter Dunlap 	iscsit_config_destroy_tpgs(&tpg_del_list);
2876a6d42e7dSPeter Dunlap 
2877a6d42e7dSPeter Dunlap 	list_destroy(&tpg_del_list);
2878a6d42e7dSPeter Dunlap 
2879a6d42e7dSPeter Dunlap 	return (ITCFG_SUCCESS);
2880a6d42e7dSPeter Dunlap }
2881a6d42e7dSPeter Dunlap 
2882a6d42e7dSPeter Dunlap /*
2883a6d42e7dSPeter Dunlap  * iscsit_sna_lt[e]
2884a6d42e7dSPeter Dunlap  *
2885a6d42e7dSPeter Dunlap  * Compare serial numbers using serial number arithmetic as defined in
2886a6d42e7dSPeter Dunlap  * RFC 1982.
2887a6d42e7dSPeter Dunlap  *
2888a6d42e7dSPeter Dunlap  * NOTE: This code is duplicated in the isns server as well as iscsitgtd.  It
2889a6d42e7dSPeter Dunlap  * ought to be common.
2890a6d42e7dSPeter Dunlap  */
2891a6d42e7dSPeter Dunlap 
2892a6d42e7dSPeter Dunlap static int
2893a6d42e7dSPeter Dunlap iscsit_sna_lt(uint32_t sn1, uint32_t sn2)
2894a6d42e7dSPeter Dunlap {
2895a6d42e7dSPeter Dunlap 	return ((sn1 != sn2) &&
2896a6d42e7dSPeter Dunlap 	    (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) ||
2897a6d42e7dSPeter Dunlap 	    ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK))));
2898a6d42e7dSPeter Dunlap }
2899a6d42e7dSPeter Dunlap 
2900a6d42e7dSPeter Dunlap static int
2901a6d42e7dSPeter Dunlap iscsit_sna_lte(uint32_t sn1, uint32_t sn2)
2902a6d42e7dSPeter Dunlap {
2903a6d42e7dSPeter Dunlap 	return ((sn1 == sn2) ||
2904a6d42e7dSPeter Dunlap 	    (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) ||
2905a6d42e7dSPeter Dunlap 	    ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK))));
2906a6d42e7dSPeter Dunlap }
2907a6d42e7dSPeter Dunlap 
2908a6d42e7dSPeter Dunlap 
2909a6d42e7dSPeter Dunlap static boolean_t
2910a6d42e7dSPeter Dunlap iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn)
2911a6d42e7dSPeter Dunlap {
2912a6d42e7dSPeter Dunlap 	iscsit_sess_t	*ist = ict->ict_sess;
2913a6d42e7dSPeter Dunlap 	int		rval = B_TRUE;
2914a6d42e7dSPeter Dunlap 
2915a6d42e7dSPeter Dunlap 	ist = ict->ict_sess;
2916a6d42e7dSPeter Dunlap 
2917a6d42e7dSPeter Dunlap 	rw_enter(&ist->ist_sn_rwlock, RW_READER);
2918a6d42e7dSPeter Dunlap 
2919a6d42e7dSPeter Dunlap 	/*
2920a6d42e7dSPeter Dunlap 	 * If cmdsn is less than ist_expcmdsn - iscsit_cmd_window() or
2921a6d42e7dSPeter Dunlap 	 * greater than ist_expcmdsn, it's not in the window.
2922a6d42e7dSPeter Dunlap 	 */
2923a6d42e7dSPeter Dunlap 
2924a6d42e7dSPeter Dunlap 	if (iscsit_sna_lt(cmdsn, (ist->ist_expcmdsn - iscsit_cmd_window())) ||
2925a6d42e7dSPeter Dunlap 	    !iscsit_sna_lte(cmdsn, ist->ist_expcmdsn)) {
2926a6d42e7dSPeter Dunlap 		rval = B_FALSE;
2927a6d42e7dSPeter Dunlap 	}
2928a6d42e7dSPeter Dunlap 
2929a6d42e7dSPeter Dunlap 	rw_exit(&ist->ist_sn_rwlock);
2930a6d42e7dSPeter Dunlap 
2931a6d42e7dSPeter Dunlap 	return (rval);
2932a6d42e7dSPeter Dunlap }
2933