xref: /illumos-gate/usr/src/uts/common/io/idm/idm_impl.c (revision 8e718be9)
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 
22a6d42e7dSPeter Dunlap /*
23c2b2c94bSPeter Gill  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24a6d42e7dSPeter Dunlap  */
25a6d42e7dSPeter Dunlap 
26a6d42e7dSPeter Dunlap #include <sys/conf.h>
27a6d42e7dSPeter Dunlap #include <sys/file.h>
28a6d42e7dSPeter Dunlap #include <sys/ddi.h>
29a6d42e7dSPeter Dunlap #include <sys/sunddi.h>
30a6d42e7dSPeter Dunlap #include <sys/cpuvar.h>
31a668b114SPriya Krishnan #include <sys/sdt.h>
32a6d42e7dSPeter Dunlap 
33a6d42e7dSPeter Dunlap #include <sys/socket.h>
34a6d42e7dSPeter Dunlap #include <sys/strsubr.h>
35a6d42e7dSPeter Dunlap #include <sys/socketvar.h>
36a6d42e7dSPeter Dunlap #include <sys/sysmacros.h>
37a6d42e7dSPeter Dunlap 
38a6d42e7dSPeter Dunlap #include <sys/idm/idm.h>
39a6d42e7dSPeter Dunlap #include <sys/idm/idm_so.h>
40d4b0f847SJack Meng #include <hd_crc.h>
41a6d42e7dSPeter Dunlap 
42a6d42e7dSPeter Dunlap extern idm_transport_t  idm_transport_list[];
43d4b0f847SJack Meng /*
44d4b0f847SJack Meng  * -1 - uninitialized
45d4b0f847SJack Meng  * 0  - applicable
46d4b0f847SJack Meng  * others - NA
47d4b0f847SJack Meng  */
48d4b0f847SJack Meng static int iscsi_crc32_hd = -1;
49a6d42e7dSPeter Dunlap 
50a6d42e7dSPeter Dunlap void
idm_pdu_rx(idm_conn_t * ic,idm_pdu_t * pdu)51a6d42e7dSPeter Dunlap idm_pdu_rx(idm_conn_t *ic, idm_pdu_t *pdu)
52a6d42e7dSPeter Dunlap {
53a6d42e7dSPeter Dunlap 	iscsi_async_evt_hdr_t *async_evt;
54a6d42e7dSPeter Dunlap 
55a6d42e7dSPeter Dunlap 	/*
56a6d42e7dSPeter Dunlap 	 * If we are in full-featured mode then route SCSI-related
57a6d42e7dSPeter Dunlap 	 * commands to the appropriate function vector
58a6d42e7dSPeter Dunlap 	 */
59a6d42e7dSPeter Dunlap 	ic->ic_timestamp = ddi_get_lbolt();
60a6d42e7dSPeter Dunlap 	mutex_enter(&ic->ic_state_mutex);
61a6d42e7dSPeter Dunlap 	if (ic->ic_ffp && ic->ic_pdu_events == 0) {
62a6d42e7dSPeter Dunlap 		mutex_exit(&ic->ic_state_mutex);
63a6d42e7dSPeter Dunlap 
64a6d42e7dSPeter Dunlap 		if (idm_pdu_rx_forward_ffp(ic, pdu) == B_TRUE) {
65a6d42e7dSPeter Dunlap 			/* Forwarded SCSI-related commands */
66a6d42e7dSPeter Dunlap 			return;
67a6d42e7dSPeter Dunlap 		}
68a6d42e7dSPeter Dunlap 		mutex_enter(&ic->ic_state_mutex);
69a6d42e7dSPeter Dunlap 	}
70a6d42e7dSPeter Dunlap 
71a6d42e7dSPeter Dunlap 	/*
72a6d42e7dSPeter Dunlap 	 * If we get here with a SCSI-related PDU then we are not in
73a6d42e7dSPeter Dunlap 	 * full-feature mode and the PDU is a protocol error (SCSI command
74a6d42e7dSPeter Dunlap 	 * PDU's may sometimes be an exception, see below).  All
75a6d42e7dSPeter Dunlap 	 * non-SCSI PDU's get treated them the same regardless of whether
76a6d42e7dSPeter Dunlap 	 * we are in full-feature mode.
77a6d42e7dSPeter Dunlap 	 *
78a6d42e7dSPeter Dunlap 	 * Look at the opcode and in some cases the PDU status and
79a6d42e7dSPeter Dunlap 	 * determine the appropriate event to send to the connection
80a6d42e7dSPeter Dunlap 	 * state machine.  Generate the event, passing the PDU as data.
81a6d42e7dSPeter Dunlap 	 * If the current connection state allows reception of the event
82a6d42e7dSPeter Dunlap 	 * the PDU will be submitted to the IDM client for processing,
83a6d42e7dSPeter Dunlap 	 * otherwise the PDU will be dropped.
84a6d42e7dSPeter Dunlap 	 */
85a6d42e7dSPeter Dunlap 	switch (IDM_PDU_OPCODE(pdu)) {
86a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGIN_CMD:
87a668b114SPriya Krishnan 		DTRACE_ISCSI_2(login__command, idm_conn_t *, ic,
88a668b114SPriya Krishnan 		    iscsi_login_hdr_t *, (iscsi_login_hdr_t *)pdu->isp_hdr);
89a6d42e7dSPeter Dunlap 		idm_conn_rx_pdu_event(ic, CE_LOGIN_RCV, (uintptr_t)pdu);
90a6d42e7dSPeter Dunlap 		break;
91a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGIN_RSP:
92a6d42e7dSPeter Dunlap 		idm_parse_login_rsp(ic, pdu, /* RX */ B_TRUE);
93a6d42e7dSPeter Dunlap 		break;
94a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGOUT_CMD:
95a668b114SPriya Krishnan 		DTRACE_ISCSI_2(logout__command, idm_conn_t *, ic,
96a668b114SPriya Krishnan 		    iscsi_logout_hdr_t *,
97a668b114SPriya Krishnan 		    (iscsi_logout_hdr_t *)pdu->isp_hdr);
98a6d42e7dSPeter Dunlap 		idm_parse_logout_req(ic, pdu, /* RX */ B_TRUE);
99a6d42e7dSPeter Dunlap 		break;
100a6d42e7dSPeter Dunlap 	case ISCSI_OP_LOGOUT_RSP:
101a6d42e7dSPeter Dunlap 		idm_parse_logout_rsp(ic, pdu, /* RX */ B_TRUE);
102a6d42e7dSPeter Dunlap 		break;
103a6d42e7dSPeter Dunlap 	case ISCSI_OP_ASYNC_EVENT:
104a6d42e7dSPeter Dunlap 		async_evt = (iscsi_async_evt_hdr_t *)pdu->isp_hdr;
10530e7468fSPeter Dunlap 		switch (async_evt->async_event) {
106a6d42e7dSPeter Dunlap 		case ISCSI_ASYNC_EVENT_REQUEST_LOGOUT:
107a6d42e7dSPeter Dunlap 			idm_conn_rx_pdu_event(ic, CE_ASYNC_LOGOUT_RCV,
108a6d42e7dSPeter Dunlap 			    (uintptr_t)pdu);
109a6d42e7dSPeter Dunlap 			break;
111a6d42e7dSPeter Dunlap 			idm_conn_rx_pdu_event(ic, CE_ASYNC_DROP_CONN_RCV,
112a6d42e7dSPeter Dunlap 			    (uintptr_t)pdu);
113a6d42e7dSPeter Dunlap 			break;
115a6d42e7dSPeter Dunlap 			idm_conn_rx_pdu_event(ic, CE_ASYNC_DROP_ALL_CONN_RCV,
116a6d42e7dSPeter Dunlap 			    (uintptr_t)pdu);
117a6d42e7dSPeter Dunlap 			break;
118a6d42e7dSPeter Dunlap 		case ISCSI_ASYNC_EVENT_SCSI_EVENT:
119a6d42e7dSPeter Dunlap 		case ISCSI_ASYNC_EVENT_PARAM_NEGOTIATION:
120a6d42e7dSPeter Dunlap 		default:
121a6d42e7dSPeter Dunlap 			idm_conn_rx_pdu_event(ic, CE_MISC_RX,
122a6d42e7dSPeter Dunlap 			    (uintptr_t)pdu);
123a6d42e7dSPeter Dunlap 			break;
124a6d42e7dSPeter Dunlap 		}
125a6d42e7dSPeter Dunlap 		break;
126a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_CMD:
127a6d42e7dSPeter Dunlap 		/*
128a6d42e7dSPeter Dunlap 		 * Consider this scenario:  We are a target connection
129a6d42e7dSPeter Dunlap 		 * in "in login" state and a "login success sent" event has
130a6d42e7dSPeter Dunlap 		 * been generated but not yet handled.  Since we've sent
131a6d42e7dSPeter Dunlap 		 * the login response but we haven't actually transitioned
132a6d42e7dSPeter Dunlap 		 * to FFP mode we might conceivably receive a SCSI command
133a6d42e7dSPeter Dunlap 		 * from the initiator before we are ready.  We are actually
134a6d42e7dSPeter Dunlap 		 * in FFP we just don't know it yet -- to address this we
135a6d42e7dSPeter Dunlap 		 * can generate an event corresponding to the SCSI command.
136a6d42e7dSPeter Dunlap 		 * At the point when the event is handled by the state
137a6d42e7dSPeter Dunlap 		 * machine the login request will have been handled and we
138a6d42e7dSPeter Dunlap 		 * should be in FFP.  If we are not in FFP by that time
139a6d42e7dSPeter Dunlap 		 * we can reject the SCSI command with a protocol error.
140a6d42e7dSPeter Dunlap 		 *
141a6d42e7dSPeter Dunlap 		 * This scenario only applies to the target.
142a668b114SPriya Krishnan 		 *
143a668b114SPriya Krishnan 		 * Handle dtrace probe in iscsit so we can find all the
144a668b114SPriya Krishnan 		 * pieces of the CDB
145a6d42e7dSPeter Dunlap 		 */
146a668b114SPriya Krishnan 		idm_conn_rx_pdu_event(ic, CE_MISC_RX, (uintptr_t)pdu);
147a668b114SPriya Krishnan 		break;
148a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_DATA:
149a668b114SPriya Krishnan 		DTRACE_ISCSI_2(data__receive, idm_conn_t *, ic,
150a668b114SPriya Krishnan 		    iscsi_data_hdr_t *,
151a668b114SPriya Krishnan 		    (iscsi_data_hdr_t *)pdu->isp_hdr);
152a668b114SPriya Krishnan 		idm_conn_rx_pdu_event(ic, CE_MISC_RX, (uintptr_t)pdu);
153a668b114SPriya Krishnan 		break;
154a668b114SPriya Krishnan 	case ISCSI_OP_SCSI_TASK_MGT_MSG:
155a668b114SPriya Krishnan 		DTRACE_ISCSI_2(task__command, idm_conn_t *, ic,
156a668b114SPriya Krishnan 		    iscsi_scsi_task_mgt_hdr_t *,
157a668b114SPriya Krishnan 		    (iscsi_scsi_task_mgt_hdr_t *)pdu->isp_hdr);
158a668b114SPriya Krishnan 		idm_conn_rx_pdu_event(ic, CE_MISC_RX, (uintptr_t)pdu);
159a668b114SPriya Krishnan 		break;
160a668b114SPriya Krishnan 	case ISCSI_OP_NOOP_OUT:
161a668b114SPriya Krishnan 		DTRACE_ISCSI_2(nop__receive, idm_conn_t *, ic,
162a668b114SPriya Krishnan 		    iscsi_nop_out_hdr_t *,
163a668b114SPriya Krishnan 		    (iscsi_nop_out_hdr_t *)pdu->isp_hdr);
164a668b114SPriya Krishnan 		idm_conn_rx_pdu_event(ic, CE_MISC_RX, (uintptr_t)pdu);
165a668b114SPriya Krishnan 		break;
166a668b114SPriya Krishnan 	case ISCSI_OP_TEXT_CMD:
167a668b114SPriya Krishnan 		DTRACE_ISCSI_2(text__command, idm_conn_t *, ic,
168a668b114SPriya Krishnan 		    iscsi_text_hdr_t *,
169a668b114SPriya Krishnan 		    (iscsi_text_hdr_t *)pdu->isp_hdr);
170a668b114SPriya Krishnan 		idm_conn_rx_pdu_event(ic, CE_MISC_RX, (uintptr_t)pdu);
171a668b114SPriya Krishnan 		break;
172a668b114SPriya Krishnan 	/* Initiator PDU's */
173a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_DATA_RSP:
174a6d42e7dSPeter Dunlap 	case ISCSI_OP_RTT_RSP:
175a6d42e7dSPeter Dunlap 	case ISCSI_OP_SNACK_CMD:
176a6d42e7dSPeter Dunlap 	case ISCSI_OP_NOOP_IN:
177a6d42e7dSPeter Dunlap 	case ISCSI_OP_TEXT_RSP:
178a6d42e7dSPeter Dunlap 	case ISCSI_OP_REJECT_MSG:
179a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_TASK_MGT_RSP:
180a6d42e7dSPeter Dunlap 		/* Validate received PDU against current state */
181a6d42e7dSPeter Dunlap 		idm_conn_rx_pdu_event(ic, CE_MISC_RX,
182a6d42e7dSPeter Dunlap 		    (uintptr_t)pdu);
183a6d42e7dSPeter Dunlap 		break;
184a6d42e7dSPeter Dunlap 	}
185a6d42e7dSPeter Dunlap 	mutex_exit(&ic->ic_state_mutex);
186a6d42e7dSPeter Dunlap }
187a6d42e7dSPeter Dunlap 
188a6d42e7dSPeter Dunlap void
idm_pdu_tx_forward(idm_conn_t * ic,idm_pdu_t * pdu)189a6d42e7dSPeter Dunlap idm_pdu_tx_forward(idm_conn_t *ic, idm_pdu_t *pdu)
190a6d42e7dSPeter Dunlap {
191a6d42e7dSPeter Dunlap 	(*ic->ic_transport_ops->it_tx_pdu)(ic, pdu);
192a6d42e7dSPeter Dunlap }
193a6d42e7dSPeter Dunlap 
194a6d42e7dSPeter Dunlap boolean_t
idm_pdu_rx_forward_ffp(idm_conn_t * ic,idm_pdu_t * pdu)195a6d42e7dSPeter Dunlap idm_pdu_rx_forward_ffp(idm_conn_t *ic, idm_pdu_t *pdu)
196a6d42e7dSPeter Dunlap {
197a6d42e7dSPeter Dunlap 	/*
198a6d42e7dSPeter Dunlap 	 * If this is an FFP request, call the appropriate handler
199a6d42e7dSPeter Dunlap 	 * and return B_TRUE, otherwise return B_FALSE.
200a6d42e7dSPeter Dunlap 	 */
201a6d42e7dSPeter Dunlap 	switch (IDM_PDU_OPCODE(pdu)) {
202a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_CMD:
203a6d42e7dSPeter Dunlap 		(*ic->ic_conn_ops.icb_rx_scsi_cmd)(ic, pdu);
204a6d42e7dSPeter Dunlap 		return (B_TRUE);
205a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_DATA:
206a668b114SPriya Krishnan 		DTRACE_ISCSI_2(data__receive, idm_conn_t *, ic,
207a668b114SPriya Krishnan 		    iscsi_data_hdr_t *,
208a668b114SPriya Krishnan 		    (iscsi_data_hdr_t *)pdu->isp_hdr);
209a6d42e7dSPeter Dunlap 		(*ic->ic_transport_ops->it_rx_dataout)(ic, pdu);
210a6d42e7dSPeter Dunlap 		return (B_TRUE);
211a668b114SPriya Krishnan 	case ISCSI_OP_SCSI_TASK_MGT_MSG:
212a668b114SPriya Krishnan 		DTRACE_ISCSI_2(task__command, idm_conn_t *, ic,
213a668b114SPriya Krishnan 		    iscsi_scsi_task_mgt_hdr_t *,
214a668b114SPriya Krishnan 		    (iscsi_scsi_task_mgt_hdr_t *)pdu->isp_hdr);
215a668b114SPriya Krishnan 		(*ic->ic_conn_ops.icb_rx_misc)(ic, pdu);
216a668b114SPriya Krishnan 		return (B_TRUE);
217a668b114SPriya Krishnan 	case ISCSI_OP_NOOP_OUT:
218a668b114SPriya Krishnan 		DTRACE_ISCSI_2(nop__receive, idm_conn_t *, ic,
219a668b114SPriya Krishnan 		    iscsi_nop_out_hdr_t *,
220a668b114SPriya Krishnan 		    (iscsi_nop_out_hdr_t *)pdu->isp_hdr);
221a668b114SPriya Krishnan 		(*ic->ic_conn_ops.icb_rx_misc)(ic, pdu);
222a668b114SPriya Krishnan 		return (B_TRUE);
223a668b114SPriya Krishnan 	case ISCSI_OP_TEXT_CMD:
224a668b114SPriya Krishnan 		DTRACE_ISCSI_2(text__command, idm_conn_t *, ic,
225a668b114SPriya Krishnan 		    iscsi_text_hdr_t *,
226a668b114SPriya Krishnan 		    (iscsi_text_hdr_t *)pdu->isp_hdr);
227a668b114SPriya Krishnan 		(*ic->ic_conn_ops.icb_rx_misc)(ic, pdu);
228a668b114SPriya Krishnan 		return (B_TRUE);
229a668b114SPriya Krishnan 		/* Initiator only */
230a668b114SPriya Krishnan 	case ISCSI_OP_SCSI_RSP:
231a668b114SPriya Krishnan 		(*ic->ic_conn_ops.icb_rx_scsi_rsp)(ic, pdu);
232a668b114SPriya Krishnan 		return (B_TRUE);
233a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_DATA_RSP:
234a6d42e7dSPeter Dunlap 		(*ic->ic_transport_ops->it_rx_datain)(ic, pdu);
235a6d42e7dSPeter Dunlap 		return (B_TRUE);
236a6d42e7dSPeter Dunlap 	case ISCSI_OP_RTT_RSP:
237a6d42e7dSPeter Dunlap 		(*ic->ic_transport_ops->it_rx_rtt)(ic, pdu);
238a6d42e7dSPeter Dunlap 		return (B_TRUE);
239a6d42e7dSPeter Dunlap 	case ISCSI_OP_SCSI_TASK_MGT_RSP:
240a6d42e7dSPeter Dunlap 	case ISCSI_OP_TEXT_RSP:
241a6d42e7dSPeter Dunlap 	case ISCSI_OP_NOOP_IN:
242a6d42e7dSPeter Dunlap 		(*ic->ic_conn_ops.icb_rx_misc)(ic, pdu);
243a6d42e7dSPeter Dunlap 		return (B_TRUE);
244a6d42e7dSPeter Dunlap 	default:
245a6d42e7dSPeter Dunlap 		return (B_FALSE);
246a6d42e7dSPeter Dunlap 	}
247a6d42e7dSPeter Dunlap 	/*NOTREACHED*/
248a6d42e7dSPeter Dunlap }
249a6d42e7dSPeter Dunlap 
250a6d42e7dSPeter Dunlap void
idm_pdu_rx_forward(idm_conn_t * ic,idm_pdu_t * pdu)251a6d42e7dSPeter Dunlap idm_pdu_rx_forward(idm_conn_t *ic, idm_pdu_t *pdu)
252a6d42e7dSPeter Dunlap {
253a6d42e7dSPeter Dunlap 	/*
254a6d42e7dSPeter Dunlap 	 * Some PDU's specific to FFP get special handling.  This function
255a6d42e7dSPeter Dunlap 	 * will normally never be called in FFP with an FFP PDU since this
256a6d42e7dSPeter Dunlap 	 * is a slow path but in can happen on the target side during
257a6d42e7dSPeter Dunlap 	 * the transition to FFP.  We primarily call
258a6d42e7dSPeter Dunlap 	 * idm_pdu_rx_forward_ffp here to avoid code duplication.
259a6d42e7dSPeter Dunlap 	 */
260a6d42e7dSPeter Dunlap 	if (idm_pdu_rx_forward_ffp(ic, pdu) == B_FALSE) {
261a6d42e7dSPeter Dunlap 		/*
262a6d42e7dSPeter Dunlap 		 * Non-FFP PDU, use generic RC handler
263a6d42e7dSPeter Dunlap 		 */
264a6d42e7dSPeter Dunlap 		(*ic->ic_conn_ops.icb_rx_misc)(ic, pdu);
265a6d42e7dSPeter Dunlap 	}
266a6d42e7dSPeter Dunlap }
267a6d42e7dSPeter Dunlap 
268a6d42e7dSPeter Dunlap void
idm_parse_login_rsp(idm_conn_t * ic,idm_pdu_t * login_rsp_pdu,boolean_t rx)269a6d42e7dSPeter Dunlap idm_parse_login_rsp(idm_conn_t *ic, idm_pdu_t *login_rsp_pdu, boolean_t rx)
270a6d42e7dSPeter Dunlap {
271a6d42e7dSPeter Dunlap 	iscsi_login_rsp_hdr_t	*login_rsp =
272a6d42e7dSPeter Dunlap 	    (iscsi_login_rsp_hdr_t *)login_rsp_pdu->isp_hdr;
273a6d42e7dSPeter Dunlap 	idm_conn_event_t	new_event;
274a6d42e7dSPeter Dunlap 
275a6d42e7dSPeter Dunlap 	if (login_rsp->status_class == ISCSI_STATUS_CLASS_SUCCESS) {
276a6d42e7dSPeter Dunlap 		if (!(login_rsp->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
277a6d42e7dSPeter Dunlap 		    (login_rsp->flags & ISCSI_FLAG_LOGIN_TRANSIT) &&
278a6d42e7dSPeter Dunlap 		    (ISCSI_LOGIN_NEXT_STAGE(login_rsp->flags) ==
279a6d42e7dSPeter Dunlap 		    ISCSI_FULL_FEATURE_PHASE)) {
280a6d42e7dSPeter Dunlap 			new_event = (rx ? CE_LOGIN_SUCCESS_RCV :
281a6d42e7dSPeter Dunlap 			    CE_LOGIN_SUCCESS_SND);
282a6d42e7dSPeter Dunlap 		} else {
283a6d42e7dSPeter Dunlap 			new_event = (rx ? CE_MISC_RX : CE_MISC_TX);
284a6d42e7dSPeter Dunlap 		}
285a6d42e7dSPeter Dunlap 	} else {
286a6d42e7dSPeter Dunlap 		new_event = (rx ? CE_LOGIN_FAIL_RCV : CE_LOGIN_FAIL_SND);
287a6d42e7dSPeter Dunlap 	}
288a6d42e7dSPeter Dunlap 
289a6d42e7dSPeter Dunlap 	if (rx) {
290a6d42e7dSPeter Dunlap 		idm_conn_rx_pdu_event(ic, new_event, (uintptr_t)login_rsp_pdu);
291a6d42e7dSPeter Dunlap 	} else {
292a6d42e7dSPeter Dunlap 		idm_conn_tx_pdu_event(ic, new_event, (uintptr_t)login_rsp_pdu);
293a6d42e7dSPeter Dunlap 	}
294a6d42e7dSPeter Dunlap }
295a6d42e7dSPeter Dunlap 
296a6d42e7dSPeter Dunlap 
297a6d42e7dSPeter Dunlap void
idm_parse_logout_req(idm_conn_t * ic,idm_pdu_t * logout_req_pdu,boolean_t rx)298a6d42e7dSPeter Dunlap idm_parse_logout_req(idm_conn_t *ic, idm_pdu_t *logout_req_pdu, boolean_t rx)
299a6d42e7dSPeter Dunlap {
300*8e718be9SToomas Soome 	iscsi_logout_hdr_t	*logout_req =
301a6d42e7dSPeter Dunlap 	    (iscsi_logout_hdr_t *)logout_req_pdu->isp_hdr;
302a6d42e7dSPeter Dunlap 	idm_conn_event_t	new_event;
303a6d42e7dSPeter Dunlap 	uint8_t			reason =
304a6d42e7dSPeter Dunlap 	    (logout_req->flags & ISCSI_FLAG_LOGOUT_REASON_MASK);
305a6d42e7dSPeter Dunlap 
306a6d42e7dSPeter Dunlap 	/*
307a6d42e7dSPeter Dunlap 	 *	For a normal logout (close connection or close session) IDM
308a6d42e7dSPeter Dunlap 	 *	will terminate processing of all tasks completing the tasks
309a6d42e7dSPeter Dunlap 	 *	back to the client with a status indicating the connection
310a6d42e7dSPeter Dunlap 	 *	was logged out.  These tasks do not get completed.
311a6d42e7dSPeter Dunlap 	 *
312a6d42e7dSPeter Dunlap 	 *	For a "close connection for recovery logout) IDM suspends
313a6d42e7dSPeter Dunlap 	 *	processing of all tasks and completes them back to the client
314a6d42e7dSPeter Dunlap 	 *	with a status indicating connection was logged out for
315a6d42e7dSPeter Dunlap 	 *	recovery.  Both initiator and target hang onto these tasks.
316a6d42e7dSPeter Dunlap 	 *	When we add ERL2 support IDM will need to provide mechanisms
317a6d42e7dSPeter Dunlap 	 *	to change the task and buffer associations to a new connection.
318a6d42e7dSPeter Dunlap 	 *
319a6d42e7dSPeter Dunlap 	 *	This code doesn't address the possibility of MC/S.  We'll
320a6d42e7dSPeter Dunlap 	 *	need to decide how the separate connections get handled
321a6d42e7dSPeter Dunlap 	 *	in that case.  One simple option is to make the client
322a6d42e7dSPeter Dunlap 	 *	generate the events for the other connections.
323a6d42e7dSPeter Dunlap 	 */
324a6d42e7dSPeter Dunlap 	if (reason == ISCSI_LOGOUT_REASON_CLOSE_SESSION) {
325a6d42e7dSPeter Dunlap 		new_event =
326a6d42e7dSPeter Dunlap 		    (rx ? CE_LOGOUT_SESSION_RCV : CE_LOGOUT_SESSION_SND);
327a6d42e7dSPeter Dunlap 	} else if ((reason == ISCSI_LOGOUT_REASON_CLOSE_CONNECTION) ||
328a6d42e7dSPeter Dunlap 	    (reason == ISCSI_LOGOUT_REASON_RECOVERY)) {
329a6d42e7dSPeter Dunlap 		/* Check logout CID against this connection's CID */
330a6d42e7dSPeter Dunlap 		if (ntohs(logout_req->cid) == ic->ic_login_cid) {
331a6d42e7dSPeter Dunlap 			/* Logout is for this connection */
332a6d42e7dSPeter Dunlap 			new_event = (rx ? CE_LOGOUT_THIS_CONN_RCV :
333a6d42e7dSPeter Dunlap 			    CE_LOGOUT_THIS_CONN_SND);
334a6d42e7dSPeter Dunlap 		} else {
335a6d42e7dSPeter Dunlap 			/*
336a6d42e7dSPeter Dunlap 			 * Logout affects another connection.  This is not
337a6d42e7dSPeter Dunlap 			 * a relevant event for this connection so we'll
338a6d42e7dSPeter Dunlap 			 * just treat it as a normal PDU event.  Client
339a6d42e7dSPeter Dunlap 			 * will need to lookup the other connection and
340a6d42e7dSPeter Dunlap 			 * generate the event.
341a6d42e7dSPeter Dunlap 			 */
342a6d42e7dSPeter Dunlap 			new_event = (rx ? CE_MISC_RX : CE_MISC_TX);
343a6d42e7dSPeter Dunlap 		}
344a6d42e7dSPeter Dunlap 	} else {
345a6d42e7dSPeter Dunlap 		/* Invalid reason code */
346a6d42e7dSPeter Dunlap 		new_event = (rx ? CE_RX_PROTOCOL_ERROR : CE_TX_PROTOCOL_ERROR);
347a6d42e7dSPeter Dunlap 	}
348a6d42e7dSPeter Dunlap 
349a6d42e7dSPeter Dunlap 	if (rx) {
350a6d42e7dSPeter Dunlap 		idm_conn_rx_pdu_event(ic, new_event, (uintptr_t)logout_req_pdu);
351a6d42e7dSPeter Dunlap 	} else {
352a6d42e7dSPeter Dunlap 		idm_conn_tx_pdu_event(ic, new_event, (uintptr_t)logout_req_pdu);
353a6d42e7dSPeter Dunlap 	}
354a6d42e7dSPeter Dunlap }
355a6d42e7dSPeter Dunlap 
356a6d42e7dSPeter Dunlap 
357a6d42e7dSPeter Dunlap 
358a6d42e7dSPeter Dunlap void
idm_parse_logout_rsp(idm_conn_t * ic,idm_pdu_t * logout_rsp_pdu,boolean_t rx)359a6d42e7dSPeter Dunlap idm_parse_logout_rsp(idm_conn_t *ic, idm_pdu_t *logout_rsp_pdu, boolean_t rx)
360a6d42e7dSPeter Dunlap {
361a6d42e7dSPeter Dunlap 	idm_conn_event_t	new_event;
362a6d42e7dSPeter Dunlap 	iscsi_logout_rsp_hdr_t *logout_rsp =
363a6d42e7dSPeter Dunlap 	    (iscsi_logout_rsp_hdr_t *)logout_rsp_pdu->isp_hdr;
364a6d42e7dSPeter Dunlap 
365a6d42e7dSPeter Dunlap 	if (logout_rsp->response == ISCSI_STATUS_CLASS_SUCCESS) {
366a6d42e7dSPeter Dunlap 		new_event = rx ? CE_LOGOUT_SUCCESS_RCV : CE_LOGOUT_SUCCESS_SND;
367a6d42e7dSPeter Dunlap 	} else {
368a6d42e7dSPeter Dunlap 		new_event = rx ? CE_LOGOUT_FAIL_RCV : CE_LOGOUT_FAIL_SND;
369a6d42e7dSPeter Dunlap 	}
370a6d42e7dSPeter Dunlap 
371a6d42e7dSPeter Dunlap 	if (rx) {
372a6d42e7dSPeter Dunlap 		idm_conn_rx_pdu_event(ic, new_event, (uintptr_t)logout_rsp_pdu);
373a6d42e7dSPeter Dunlap 	} else {
374a6d42e7dSPeter Dunlap 		idm_conn_tx_pdu_event(ic, new_event, (uintptr_t)logout_rsp_pdu);
375a6d42e7dSPeter Dunlap 	}
376a6d42e7dSPeter Dunlap }
377a6d42e7dSPeter Dunlap 
378a6d42e7dSPeter Dunlap /*
379a6d42e7dSPeter Dunlap  * idm_svc_conn_create()
380a6d42e7dSPeter Dunlap  * Transport-agnostic service connection creation, invoked from the transport
381a6d42e7dSPeter Dunlap  * layer.
382a6d42e7dSPeter Dunlap  */
383a6d42e7dSPeter Dunlap idm_status_t
idm_svc_conn_create(idm_svc_t * is,idm_transport_type_t tt,idm_conn_t ** ic_result)384a6d42e7dSPeter Dunlap idm_svc_conn_create(idm_svc_t *is, idm_transport_type_t tt,
385a6d42e7dSPeter Dunlap     idm_conn_t **ic_result)
386a6d42e7dSPeter Dunlap {
387a6d42e7dSPeter Dunlap 	idm_conn_t	*ic;
388a6d42e7dSPeter Dunlap 	idm_status_t	rc;
389a6d42e7dSPeter Dunlap 
39092adbba7SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	/*
39192adbba7SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * Skip some work if we can already tell we are going offline.
39292adbba7SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * Otherwise we will destroy this connection later as part of
39392adbba7SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 * shutting down the svc.
39492adbba7SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	 */
39530e7468fSPeter Dunlap 	mutex_enter(&is->is_mutex);
39630e7468fSPeter Dunlap 	if (!is->is_online) {
39730e7468fSPeter Dunlap 		mutex_exit(&is->is_mutex);
39830e7468fSPeter Dunlap 		return (IDM_STATUS_FAIL);
39930e7468fSPeter Dunlap 	}
40030e7468fSPeter Dunlap 	mutex_exit(&is->is_mutex);
40130e7468fSPeter Dunlap 
402a6d42e7dSPeter Dunlap 	ic = idm_conn_create_common(CONN_TYPE_TGT, tt,
403a6d42e7dSPeter Dunlap 	    &is->is_svc_req.sr_conn_ops);
404e97fb153SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	if (ic == NULL) {
405e97fb153SPeter Cudhea - Sun Microsystems - Burlington, MA United States 		return (IDM_STATUS_FAIL);
406e97fb153SPeter Cudhea - Sun Microsystems - Burlington, MA United States 	}
407a6d42e7dSPeter Dunlap 	ic->ic_svc_binding = is;
408a6d42e7dSPeter Dunlap 
409a6d42e7dSPeter Dunlap 	/*
410a6d42e7dSPeter Dunlap 	 * Prepare connection state machine
411a6d42e7dSPeter Dunlap 	 */
412a6d42e7dSPeter Dunlap 	if ((rc = idm_conn_sm_init(ic)) != 0) {
413a6d42e7dSPeter Dunlap 		idm_conn_destroy_common(ic);
414a6d42e7dSPeter Dunlap 		return (rc);
415a6d42e7dSPeter Dunlap 	}
416a6d42e7dSPeter Dunlap 
417a6d42e7dSPeter Dunlap 
418a6d42e7dSPeter Dunlap 	*ic_result = ic;
419a6d42e7dSPeter Dunlap 
420a6d42e7dSPeter Dunlap 	mutex_enter(&idm.idm_global_mutex);
421a6d42e7dSPeter Dunlap 	list_insert_tail(&idm.idm_tgt_conn_list, ic);
422a6d42e7dSPeter Dunlap 	idm.idm_tgt_conn_count++;
423a6d42e7dSPeter Dunlap 	mutex_exit(&idm.idm_global_mutex);
424a6d42e7dSPeter Dunlap 
42530e7468fSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
426a6d42e7dSPeter Dunlap }
427a6d42e7dSPeter Dunlap 
428a6d42e7dSPeter Dunlap void
idm_svc_conn_destroy(idm_conn_t * ic)429a6d42e7dSPeter Dunlap idm_svc_conn_destroy(idm_conn_t *ic)
430a6d42e7dSPeter Dunlap {
431a6d42e7dSPeter Dunlap 	mutex_enter(&idm.idm_global_mutex);
432a6d42e7dSPeter Dunlap 	list_remove(&idm.idm_tgt_conn_list, ic);
433a6d42e7dSPeter Dunlap 	idm.idm_tgt_conn_count--;
434a6d42e7dSPeter Dunlap 	mutex_exit(&idm.idm_global_mutex);
435a6d42e7dSPeter Dunlap 
436a6d42e7dSPeter Dunlap 	if (ic->ic_transport_private != NULL) {
437a6d42e7dSPeter Dunlap 		ic->ic_transport_ops->it_tgt_conn_destroy(ic);
438a6d42e7dSPeter Dunlap 	}
439a6d42e7dSPeter Dunlap 	idm_conn_destroy_common(ic);
440a6d42e7dSPeter Dunlap }
441a6d42e7dSPeter Dunlap 
442a6d42e7dSPeter Dunlap /*
443a6d42e7dSPeter Dunlap  * idm_conn_create_common()
444a6d42e7dSPeter Dunlap  *
445a6d42e7dSPeter Dunlap  * Allocate and initialize IDM connection context
446a6d42e7dSPeter Dunlap  */
447a6d42e7dSPeter Dunlap idm_conn_t *
idm_conn_create_common(idm_conn_type_t conn_type,idm_transport_type_t tt,idm_conn_ops_t * conn_ops)448a6d42e7dSPeter Dunlap idm_conn_create_common(idm_conn_type_t conn_type, idm_transport_type_t tt,
449a6d42e7dSPeter Dunlap     idm_conn_ops_t *conn_ops)
450a6d42e7dSPeter Dunlap {
451a6d42e7dSPeter Dunlap 	idm_conn_t		*ic;
452a6d42e7dSPeter Dunlap 	idm_transport_t		*it;
453a6d42e7dSPeter Dunlap 	idm_transport_type_t	type;
454a6d42e7dSPeter Dunlap 
455a6d42e7dSPeter Dunlap 	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {
456a6d42e7dSPeter Dunlap 		it = &idm_transport_list[type];
457a6d42e7dSPeter Dunlap 
458a6d42e7dSPeter Dunlap 		if ((it->it_ops != NULL) && (it->it_type == tt))
459a6d42e7dSPeter Dunlap 			break;
460a6d42e7dSPeter Dunlap 	}
461a6d42e7dSPeter Dunlap 	ASSERT(it->it_type == tt);
462a6d42e7dSPeter Dunlap 	if (it->it_type != tt)
463a6d42e7dSPeter Dunlap 		return (NULL);
464a6d42e7dSPeter Dunlap 
465a6d42e7dSPeter Dunlap 	ic = kmem_zalloc(sizeof (idm_conn_t), KM_SLEEP);
466a6d42e7dSPeter Dunlap 
467a6d42e7dSPeter Dunlap 	/* Initialize data */
468a668b114SPriya Krishnan 	ic->ic_target_name[0] = '\0';
469a668b114SPriya Krishnan 	ic->ic_initiator_name[0] = '\0';
470a668b114SPriya Krishnan 	ic->ic_isid[0] = '\0';
471a668b114SPriya Krishnan 	ic->ic_tsih[0] = '\0';
472a6d42e7dSPeter Dunlap 	ic->ic_conn_type = conn_type;
473a6d42e7dSPeter Dunlap 	ic->ic_conn_ops = *conn_ops;
474a6d42e7dSPeter Dunlap 	ic->ic_transport_ops = it->it_ops;
475a6d42e7dSPeter Dunlap 	ic->ic_transport_type = tt;
476a6d42e7dSPeter Dunlap 	ic->ic_transport_private = NULL; /* Set by transport service */
477a6d42e7dSPeter Dunlap 	ic->ic_internal_cid = idm_cid_alloc();
478a6d42e7dSPeter Dunlap 	if (ic->ic_internal_cid == 0) {
479a6d42e7dSPeter Dunlap 		kmem_free(ic, sizeof (idm_conn_t));
480a6d42e7dSPeter Dunlap 		return (NULL);
481a6d42e7dSPeter Dunlap 	}
482a6d42e7dSPeter Dunlap 	mutex_init(&ic->ic_mutex, NULL, MUTEX_DEFAULT, NULL);
483a6d42e7dSPeter Dunlap 	cv_init(&ic->ic_cv, NULL, CV_DEFAULT, NULL);
484a6d42e7dSPeter Dunlap 	idm_refcnt_init(&ic->ic_refcnt, ic);
485a6d42e7dSPeter Dunlap 
486a6d42e7dSPeter Dunlap 	return (ic);
487a6d42e7dSPeter Dunlap }
488a6d42e7dSPeter Dunlap 
489a6d42e7dSPeter Dunlap void
idm_conn_destroy_common(idm_conn_t * ic)490a6d42e7dSPeter Dunlap idm_conn_destroy_common(idm_conn_t *ic)
491a6d42e7dSPeter Dunlap {
49230e7468fSPeter Dunlap 	idm_conn_sm_fini(ic);
493a6d42e7dSPeter Dunlap 	idm_refcnt_destroy(&ic->ic_refcnt);
494a6d42e7dSPeter Dunlap 	cv_destroy(&ic->ic_cv);
495a6d42e7dSPeter Dunlap 	mutex_destroy(&ic->ic_mutex);
496a6d42e7dSPeter Dunlap 	idm_cid_free(ic->ic_internal_cid);
497a6d42e7dSPeter Dunlap 
498a6d42e7dSPeter Dunlap 	kmem_free(ic, sizeof (idm_conn_t));
499a6d42e7dSPeter Dunlap }
500a6d42e7dSPeter Dunlap 
501a6d42e7dSPeter Dunlap /*
502a6d42e7dSPeter Dunlap  * Invoked from the SM as a result of client's invocation of
503a6d42e7dSPeter Dunlap  * idm_ini_conn_connect()
504a6d42e7dSPeter Dunlap  */
505a6d42e7dSPeter Dunlap idm_status_t
idm_ini_conn_finish(idm_conn_t * ic)506a6d42e7dSPeter Dunlap idm_ini_conn_finish(idm_conn_t *ic)
507a6d42e7dSPeter Dunlap {
508a6d42e7dSPeter Dunlap 	/* invoke transport-specific connection */
509a6d42e7dSPeter Dunlap 	return (ic->ic_transport_ops->it_ini_conn_connect(ic));
510a6d42e7dSPeter Dunlap }
511a6d42e7dSPeter Dunlap 
512a6d42e7dSPeter Dunlap idm_status_t
idm_tgt_conn_finish(idm_conn_t * ic)513a6d42e7dSPeter Dunlap idm_tgt_conn_finish(idm_conn_t *ic)
514a6d42e7dSPeter Dunlap {
515a6d42e7dSPeter Dunlap 	idm_status_t rc;
516a6d42e7dSPeter Dunlap 
517*8e718be9SToomas Soome 	rc = idm_notify_client(ic, CN_CONNECT_ACCEPT, (uintptr_t)NULL);
518a6d42e7dSPeter Dunlap 	if (rc != IDM_STATUS_SUCCESS) {
519a6d42e7dSPeter Dunlap 		return (IDM_STATUS_REJECT);
520a6d42e7dSPeter Dunlap 	}
521a6d42e7dSPeter Dunlap 
522a6d42e7dSPeter Dunlap 	/* Target client is ready to receive a login, start connection */
523a6d42e7dSPeter Dunlap 	return (ic->ic_transport_ops->it_tgt_conn_connect(ic));
524a6d42e7dSPeter Dunlap }
525a6d42e7dSPeter Dunlap 
526a6d42e7dSPeter Dunlap idm_transport_t *
idm_transport_lookup(idm_conn_req_t * cr)527a6d42e7dSPeter Dunlap idm_transport_lookup(idm_conn_req_t *cr)
528a6d42e7dSPeter Dunlap {
529a6d42e7dSPeter Dunlap 	idm_transport_type_t	type;
530a6d42e7dSPeter Dunlap 	idm_transport_t		*it;
531a6d42e7dSPeter Dunlap 	idm_transport_caps_t	caps;
532a6d42e7dSPeter Dunlap 
533a6d42e7dSPeter Dunlap 	/*
534a6d42e7dSPeter Dunlap 	 * Make sure all available transports are setup.  We call this now
535a6d42e7dSPeter Dunlap 	 * instead of at initialization time in case IB has become available
536a6d42e7dSPeter Dunlap 	 * since we started (hotplug, etc).
537a6d42e7dSPeter Dunlap 	 */
538bbe72583SJack Meng 	idm_transport_setup(cr->cr_li, cr->cr_boot_conn);
539a6d42e7dSPeter Dunlap 
540a6d42e7dSPeter Dunlap 	/* Determine the transport for this connection */
541a6d42e7dSPeter Dunlap 	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {
542a6d42e7dSPeter Dunlap 		it = &idm_transport_list[type];
543a6d42e7dSPeter Dunlap 
544a6d42e7dSPeter Dunlap 		if (it->it_ops == NULL) {
545a6d42e7dSPeter Dunlap 			/* transport is not registered */
546a6d42e7dSPeter Dunlap 			continue;
547a6d42e7dSPeter Dunlap 		}
548a6d42e7dSPeter Dunlap 
549a6d42e7dSPeter Dunlap 		if (it->it_ops->it_conn_is_capable(cr, &caps)) {
550a6d42e7dSPeter Dunlap 			return (it);
551a6d42e7dSPeter Dunlap 		}
552a6d42e7dSPeter Dunlap 	}
553a6d42e7dSPeter Dunlap 
554a6d42e7dSPeter Dunlap 	ASSERT(0);
555a6d42e7dSPeter Dunlap 	return (NULL); /* Make gcc happy */
556a6d42e7dSPeter Dunlap }
557a6d42e7dSPeter Dunlap 
558a6d42e7dSPeter Dunlap void
idm_transport_setup(ldi_ident_t li,boolean_t boot_conn)559bbe72583SJack Meng idm_transport_setup(ldi_ident_t li, boolean_t boot_conn)
560a6d42e7dSPeter Dunlap {
561a6d42e7dSPeter Dunlap 	idm_transport_type_t	type;
562a6d42e7dSPeter Dunlap 	idm_transport_t		*it;
563a6d42e7dSPeter Dunlap 	int			rc;
564a6d42e7dSPeter Dunlap 
565a6d42e7dSPeter Dunlap 	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {
566a6d42e7dSPeter Dunlap 		it = &idm_transport_list[type];
567a6d42e7dSPeter Dunlap 		/*
568a6d42e7dSPeter Dunlap 		 * We may want to store the LDI handle in the idm_svc_t
569a6d42e7dSPeter Dunlap 		 * and then allow multiple calls to ldi_open_by_name.  This
570a6d42e7dSPeter Dunlap 		 * would enable the LDI code to track who has the device open
571a6d42e7dSPeter Dunlap 		 * which could be useful in the case where we have multiple
572a6d42e7dSPeter Dunlap 		 * services and perhaps also have initiator and target opening
573a6d42e7dSPeter Dunlap 		 * the transport simultaneously.  For now we stick with the
574a6d42e7dSPeter Dunlap 		 * plan.
575a6d42e7dSPeter Dunlap 		 */
576a6d42e7dSPeter Dunlap 		if (it->it_ops == NULL) {
577a6d42e7dSPeter Dunlap 			/* transport is not ready, try to initialize it */
578a6d42e7dSPeter Dunlap 			if (it->it_type == IDM_TRANSPORT_TYPE_SOCKETS) {
579a6d42e7dSPeter Dunlap 				idm_so_init(it);
580a6d42e7dSPeter Dunlap 			} else {
581bbe72583SJack Meng 				if (boot_conn == B_TRUE) {
582bbe72583SJack Meng 					/*
583bbe72583SJack Meng 					 * iSCSI boot doesn't need iSER.
584bbe72583SJack Meng 					 * Open iSER here may drive IO to
585bbe72583SJack Meng 					 * a failed session and cause
586bbe72583SJack Meng 					 * deadlock
587bbe72583SJack Meng 					 */
588bbe72583SJack Meng 					continue;
589bbe72583SJack Meng 				}
590a6d42e7dSPeter Dunlap 				rc = ldi_open_by_name(it->it_device_path,
591a6d42e7dSPeter Dunlap 				    FREAD | FWRITE, kcred, &it->it_ldi_hdl, li);
592a6d42e7dSPeter Dunlap 				/*
593a6d42e7dSPeter Dunlap 				 * If the open is successful we will have
594a6d42e7dSPeter Dunlap 				 * filled in the LDI handle in the transport
595a6d42e7dSPeter Dunlap 				 * table and we expect that the transport
596a6d42e7dSPeter Dunlap 				 * registered itself.
597a6d42e7dSPeter Dunlap 				 */
598a6d42e7dSPeter Dunlap 				if (rc != 0) {
599a6d42e7dSPeter Dunlap 					it->it_ldi_hdl = NULL;
600a6d42e7dSPeter Dunlap 				}
601a6d42e7dSPeter Dunlap 			}
602a6d42e7dSPeter Dunlap 		}
603a6d42e7dSPeter Dunlap 	}
604a6d42e7dSPeter Dunlap }
605a6d42e7dSPeter Dunlap 
60630e7468fSPeter Dunlap void
idm_transport_teardown()60730e7468fSPeter Dunlap idm_transport_teardown()
60830e7468fSPeter Dunlap {
60930e7468fSPeter Dunlap 	idm_transport_type_t	type;
61030e7468fSPeter Dunlap 	idm_transport_t		*it;
61130e7468fSPeter Dunlap 
61230e7468fSPeter Dunlap 	ASSERT(mutex_owned(&idm.idm_global_mutex));
61330e7468fSPeter Dunlap 
61430e7468fSPeter Dunlap 	/* Caller holds the IDM global mutex */
61530e7468fSPeter Dunlap 	for (type = 0; type < IDM_TRANSPORT_NUM_TYPES; type++) {
61630e7468fSPeter Dunlap 		it = &idm_transport_list[type];
61730e7468fSPeter Dunlap 		/* If we have an open LDI handle on this driver, close it */
61830e7468fSPeter Dunlap 		if (it->it_ldi_hdl != NULL) {
61930e7468fSPeter Dunlap 			(void) ldi_close(it->it_ldi_hdl, FNDELAY, kcred);
62030e7468fSPeter Dunlap 			it->it_ldi_hdl = NULL;
62130e7468fSPeter Dunlap 		}
62230e7468fSPeter Dunlap 	}
62330e7468fSPeter Dunlap }
62430e7468fSPeter Dunlap 
625a6d42e7dSPeter Dunlap /*
626a6d42e7dSPeter Dunlap  * ID pool code.  We use this to generate unique structure identifiers without
627a6d42e7dSPeter Dunlap  * searching the existing structures.  This avoids the need to lock entire
628a6d42e7dSPeter Dunlap  * sets of structures at inopportune times.  Adapted from the CIFS server code.
629a6d42e7dSPeter Dunlap  *
630a6d42e7dSPeter Dunlap  *    A pool of IDs is a pool of 16 bit numbers. It is implemented as a bitmap.
631a6d42e7dSPeter Dunlap  *    A bit set to '1' indicates that that particular value has been allocated.
632a6d42e7dSPeter Dunlap  *    The allocation process is done shifting a bit through the whole bitmap.
633a6d42e7dSPeter Dunlap  *    The current position of that index bit is kept in the idm_idpool_t
634a6d42e7dSPeter Dunlap  *    structure and represented by a byte index (0 to buffer size minus 1) and
635a6d42e7dSPeter Dunlap  *    a bit index (0 to 7).
636a6d42e7dSPeter Dunlap  *
637a6d42e7dSPeter Dunlap  *    The pools start with a size of 8 bytes or 64 IDs. Each time the pool runs
638a6d42e7dSPeter Dunlap  *    out of IDs its current size is doubled until it reaches its maximum size
639a6d42e7dSPeter Dunlap  *    (8192 bytes or 65536 IDs). The IDs 0 and 65535 are never given out which
640a6d42e7dSPeter Dunlap  *    means that a pool can have a maximum number of 65534 IDs available.
641a6d42e7dSPeter Dunlap  */
642a6d42e7dSPeter Dunlap 
643a6d42e7dSPeter Dunlap static int
idm_idpool_increment(idm_idpool_t * pool)644a6d42e7dSPeter Dunlap idm_idpool_increment(
645a6d42e7dSPeter Dunlap     idm_idpool_t	*pool)
646a6d42e7dSPeter Dunlap {
647a6d42e7dSPeter Dunlap 	uint8_t		*new_pool;
648a6d42e7dSPeter Dunlap 	uint32_t	new_size;
649a6d42e7dSPeter Dunlap 
650a6d42e7dSPeter Dunlap 	ASSERT(pool->id_magic == IDM_IDPOOL_MAGIC);
651a6d42e7dSPeter Dunlap 
652a6d42e7dSPeter Dunlap 	new_size = pool->id_size * 2;
653a6d42e7dSPeter Dunlap 	if (new_size <= IDM_IDPOOL_MAX_SIZE) {
654a6d42e7dSPeter Dunlap 		new_pool = kmem_alloc(new_size / 8, KM_NOSLEEP);
655a6d42e7dSPeter Dunlap 		if (new_pool) {
656a6d42e7dSPeter Dunlap 			bzero(new_pool, new_size / 8);
657a6d42e7dSPeter Dunlap 			bcopy(pool->id_pool, new_pool, pool->id_size / 8);
658a6d42e7dSPeter Dunlap 			kmem_free(pool->id_pool, pool->id_size / 8);
659a6d42e7dSPeter Dunlap 			pool->id_pool = new_pool;
660a6d42e7dSPeter Dunlap 			pool->id_free_counter += new_size - pool->id_size;
661a6d42e7dSPeter Dunlap 			pool->id_max_free_counter += new_size - pool->id_size;
662a6d42e7dSPeter Dunlap 			pool->id_size = new_size;
663a6d42e7dSPeter Dunlap 			pool->id_idx_msk = (new_size / 8) - 1;
664a6d42e7dSPeter Dunlap 			if (new_size >= IDM_IDPOOL_MAX_SIZE) {
665a6d42e7dSPeter Dunlap 				/* id -1 made unavailable */
666a6d42e7dSPeter Dunlap 				pool->id_pool[pool->id_idx_msk] = 0x80;
667a6d42e7dSPeter Dunlap 				pool->id_free_counter--;
668a6d42e7dSPeter Dunlap 				pool->id_max_free_counter--;
669a6d42e7dSPeter Dunlap 			}
670a6d42e7dSPeter Dunlap 			return (0);
671a6d42e7dSPeter Dunlap 		}
672a6d42e7dSPeter Dunlap 	}
673a6d42e7dSPeter Dunlap 	return (-1);
674a6d42e7dSPeter Dunlap }
675a6d42e7dSPeter Dunlap 
676a6d42e7dSPeter Dunlap /*
677a6d42e7dSPeter Dunlap  * idm_idpool_constructor
678a6d42e7dSPeter Dunlap  *
679a6d42e7dSPeter Dunlap  * This function initializes the pool structure provided.
680a6d42e7dSPeter Dunlap  */
681a6d42e7dSPeter Dunlap 
682a6d42e7dSPeter Dunlap int
idm_idpool_create(idm_idpool_t * pool)683a6d42e7dSPeter Dunlap idm_idpool_create(idm_idpool_t *pool)
684a6d42e7dSPeter Dunlap {
685a6d42e7dSPeter Dunlap 
686a6d42e7dSPeter Dunlap 	ASSERT(pool->id_magic != IDM_IDPOOL_MAGIC);
687a6d42e7dSPeter Dunlap 
688a6d42e7dSPeter Dunlap 	pool->id_size = IDM_IDPOOL_MIN_SIZE;
689a6d42e7dSPeter Dunlap 	pool->id_idx_msk = (IDM_IDPOOL_MIN_SIZE / 8) - 1;
690a6d42e7dSPeter Dunlap 	pool->id_free_counter = IDM_IDPOOL_MIN_SIZE - 1;
691a6d42e7dSPeter Dunlap 	pool->id_max_free_counter = IDM_IDPOOL_MIN_SIZE - 1;
692a6d42e7dSPeter Dunlap 	pool->id_bit = 0x02;
693a6d42e7dSPeter Dunlap 	pool->id_bit_idx = 1;
694a6d42e7dSPeter Dunlap 	pool->id_idx = 0;
695a6d42e7dSPeter Dunlap 	pool->id_pool = (uint8_t *)kmem_alloc((IDM_IDPOOL_MIN_SIZE / 8),
696a6d42e7dSPeter Dunlap 	    KM_SLEEP);
697a6d42e7dSPeter Dunlap 	bzero(pool->id_pool, (IDM_IDPOOL_MIN_SIZE / 8));
698a6d42e7dSPeter Dunlap 	/* -1 id made unavailable */
699a6d42e7dSPeter Dunlap 	pool->id_pool[0] = 0x01;		/* id 0 made unavailable */
700a6d42e7dSPeter Dunlap 	mutex_init(&pool->id_mutex, NULL, MUTEX_DEFAULT, NULL);
701a6d42e7dSPeter Dunlap 	pool->id_magic = IDM_IDPOOL_MAGIC;
702a6d42e7dSPeter Dunlap 	return (0);
703a6d42e7dSPeter Dunlap }
704a6d42e7dSPeter Dunlap 
705a6d42e7dSPeter Dunlap /*
706a6d42e7dSPeter Dunlap  * idm_idpool_destructor
707a6d42e7dSPeter Dunlap  *
708a6d42e7dSPeter Dunlap  * This function tears down and frees the resources associated with the
709a6d42e7dSPeter Dunlap  * pool provided.
710a6d42e7dSPeter Dunlap  */
711a6d42e7dSPeter Dunlap 
712a6d42e7dSPeter Dunlap void
idm_idpool_destroy(idm_idpool_t * pool)713a6d42e7dSPeter Dunlap idm_idpool_destroy(idm_idpool_t *pool)
714a6d42e7dSPeter Dunlap {
715a6d42e7dSPeter Dunlap 	ASSERT(pool->id_magic == IDM_IDPOOL_MAGIC);
716a6d42e7dSPeter Dunlap 	ASSERT(pool->id_free_counter == pool->id_max_free_counter);
717a6d42e7dSPeter Dunlap 	pool->id_magic = (uint32_t)~IDM_IDPOOL_MAGIC;
718a6d42e7dSPeter Dunlap 	mutex_destroy(&pool->id_mutex);
719a6d42e7dSPeter Dunlap 	kmem_free(pool->id_pool, (size_t)(pool->id_size / 8));
720a6d42e7dSPeter Dunlap }
721a6d42e7dSPeter Dunlap 
722a6d42e7dSPeter Dunlap /*
723a6d42e7dSPeter Dunlap  * idm_idpool_alloc
724a6d42e7dSPeter Dunlap  *
725a6d42e7dSPeter Dunlap  * This function allocates an ID from the pool provided.
726a6d42e7dSPeter Dunlap  */
727a6d42e7dSPeter Dunlap int
idm_idpool_alloc(idm_idpool_t * pool,uint16_t * id)728a6d42e7dSPeter Dunlap idm_idpool_alloc(idm_idpool_t *pool, uint16_t *id)
729a6d42e7dSPeter Dunlap {
730a6d42e7dSPeter Dunlap 	uint32_t	i;
731a6d42e7dSPeter Dunlap 	uint8_t		bit;
732a6d42e7dSPeter Dunlap 	uint8_t		bit_idx;
733a6d42e7dSPeter Dunlap 	uint8_t		byte;
734a6d42e7dSPeter Dunlap 
735a6d42e7dSPeter Dunlap 	ASSERT(pool->id_magic == IDM_IDPOOL_MAGIC);
736a6d42e7dSPeter Dunlap 
737a6d42e7dSPeter Dunlap 	mutex_enter(&pool->id_mutex);
738a6d42e7dSPeter Dunlap 	if ((pool->id_free_counter == 0) && idm_idpool_increment(pool)) {
739a6d42e7dSPeter Dunlap 		mutex_exit(&pool->id_mutex);
740a6d42e7dSPeter Dunlap 		return (-1);
741a6d42e7dSPeter Dunlap 	}
742a6d42e7dSPeter Dunlap 
743a6d42e7dSPeter Dunlap 	i = pool->id_size;
744a6d42e7dSPeter Dunlap 	while (i) {
745a6d42e7dSPeter Dunlap 		bit = pool->id_bit;
746a6d42e7dSPeter Dunlap 		bit_idx = pool->id_bit_idx;
747a6d42e7dSPeter Dunlap 		byte = pool->id_pool[pool->id_idx];
748a6d42e7dSPeter Dunlap 		while (bit) {
749a6d42e7dSPeter Dunlap 			if (byte & bit) {
750a6d42e7dSPeter Dunlap 				bit = bit << 1;
751a6d42e7dSPeter Dunlap 				bit_idx++;
752a6d42e7dSPeter Dunlap 				continue;
753a6d42e7dSPeter Dunlap 			}
754a6d42e7dSPeter Dunlap 			pool->id_pool[pool->id_idx] |= bit;
755a6d42e7dSPeter Dunlap 			*id = (uint16_t)(pool->id_idx * 8 + (uint32_t)bit_idx);
756a6d42e7dSPeter Dunlap 			pool->id_free_counter--;
757a6d42e7dSPeter Dunlap 			pool->id_bit = bit;
758a6d42e7dSPeter Dunlap 			pool->id_bit_idx = bit_idx;
759a6d42e7dSPeter Dunlap 			mutex_exit(&pool->id_mutex);
760a6d42e7dSPeter Dunlap 			return (0);
761a6d42e7dSPeter Dunlap 		}
762a6d42e7dSPeter Dunlap 		pool->id_bit = 1;
763a6d42e7dSPeter Dunlap 		pool->id_bit_idx = 0;
764a6d42e7dSPeter Dunlap 		pool->id_idx++;
765a6d42e7dSPeter Dunlap 		pool->id_idx &= pool->id_idx_msk;
766a6d42e7dSPeter Dunlap 		--i;
767a6d42e7dSPeter Dunlap 	}
768a6d42e7dSPeter Dunlap 	/*
769a6d42e7dSPeter Dunlap 	 * This section of code shouldn't be reached. If there are IDs
770a6d42e7dSPeter Dunlap 	 * available and none could be found there's a problem.
771a6d42e7dSPeter Dunlap 	 */
772a6d42e7dSPeter Dunlap 	ASSERT(0);
773a6d42e7dSPeter Dunlap 	mutex_exit(&pool->id_mutex);
774a6d42e7dSPeter Dunlap 	return (-1);
775a6d42e7dSPeter Dunlap }
776a6d42e7dSPeter Dunlap 
777a6d42e7dSPeter Dunlap /*
778a6d42e7dSPeter Dunlap  * idm_idpool_free
779a6d42e7dSPeter Dunlap  *
780a6d42e7dSPeter Dunlap  * This function frees the ID provided.
781a6d42e7dSPeter Dunlap  */
782a6d42e7dSPeter Dunlap void
idm_idpool_free(idm_idpool_t * pool,uint16_t id)783a6d42e7dSPeter Dunlap idm_idpool_free(idm_idpool_t *pool, uint16_t id)
784a6d42e7dSPeter Dunlap {
785a6d42e7dSPeter Dunlap 	ASSERT(pool->id_magic == IDM_IDPOOL_MAGIC);
786a6d42e7dSPeter Dunlap 	ASSERT(id != 0);
787a6d42e7dSPeter Dunlap 	ASSERT(id != 0xFFFF);
788a6d42e7dSPeter Dunlap 
789a6d42e7dSPeter Dunlap 	mutex_enter(&pool->id_mutex);
790a6d42e7dSPeter Dunlap 	if (pool->id_pool[id >> 3] & (1 << (id & 7))) {
791a6d42e7dSPeter Dunlap 		pool->id_pool[id >> 3] &= ~(1 << (id & 7));
792a6d42e7dSPeter Dunlap 		pool->id_free_counter++;
793a6d42e7dSPeter Dunlap 		ASSERT(pool->id_free_counter <= pool->id_max_free_counter);
794a6d42e7dSPeter Dunlap 		mutex_exit(&pool->id_mutex);
795a6d42e7dSPeter Dunlap 		return;
796a6d42e7dSPeter Dunlap 	}
797a6d42e7dSPeter Dunlap 	/* Freeing a free ID. */
798a6d42e7dSPeter Dunlap 	ASSERT(0);
799a6d42e7dSPeter Dunlap 	mutex_exit(&pool->id_mutex);
800a6d42e7dSPeter Dunlap }
801a6d42e7dSPeter Dunlap 
802a6d42e7dSPeter Dunlap uint32_t
idm_cid_alloc(void)803a6d42e7dSPeter Dunlap idm_cid_alloc(void)
804a6d42e7dSPeter Dunlap {
805a6d42e7dSPeter Dunlap 	/*
806a6d42e7dSPeter Dunlap 	 * ID pool works with 16-bit identifiers right now.  That should
807a6d42e7dSPeter Dunlap 	 * be plenty since we will probably never have more than 2^16
808a6d42e7dSPeter Dunlap 	 * connections simultaneously.
809a6d42e7dSPeter Dunlap 	 */
810a6d42e7dSPeter Dunlap 	uint16_t cid16;
811a6d42e7dSPeter Dunlap 
812a6d42e7dSPeter Dunlap 	if (idm_idpool_alloc(&idm.idm_conn_id_pool, &cid16) == -1) {
813a6d42e7dSPeter Dunlap 		return (0); /* Fail */
814a6d42e7dSPeter Dunlap 	}
815a6d42e7dSPeter Dunlap 
816a6d42e7dSPeter Dunlap 	return ((uint32_t)cid16);
817a6d42e7dSPeter Dunlap }
818a6d42e7dSPeter Dunlap 
819a6d42e7dSPeter Dunlap void
idm_cid_free(uint32_t cid)820a6d42e7dSPeter Dunlap idm_cid_free(uint32_t cid)
821a6d42e7dSPeter Dunlap {
822a6d42e7dSPeter Dunlap 	idm_idpool_free(&idm.idm_conn_id_pool, (uint16_t)cid);
823a6d42e7dSPeter Dunlap }
824a6d42e7dSPeter Dunlap 
825a6d42e7dSPeter Dunlap 
826a6d42e7dSPeter Dunlap /*
827a6d42e7dSPeter Dunlap  * Code for generating the header and data digests
828a6d42e7dSPeter Dunlap  *
829a6d42e7dSPeter Dunlap  * This is the CRC-32C table
830a6d42e7dSPeter Dunlap  * Generated with:
831a6d42e7dSPeter Dunlap  * width = 32 bits
832a6d42e7dSPeter Dunlap  * poly = 0x1EDC6F41
833a6d42e7dSPeter Dunlap  * reflect input bytes = true
834a6d42e7dSPeter Dunlap  * reflect output bytes = true
835a6d42e7dSPeter Dunlap  */
836a6d42e7dSPeter Dunlap 
837a6d42e7dSPeter Dunlap uint32_t idm_crc32c_table[256] =
838a6d42e7dSPeter Dunlap {
839a6d42e7dSPeter Dunlap 	0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
840a6d42e7dSPeter Dunlap 	0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
841a6d42e7dSPeter Dunlap 	0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
842a6d42e7dSPeter Dunlap 	0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
843a6d42e7dSPeter Dunlap 	0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
844a6d42e7dSPeter Dunlap 	0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
845a6d42e7dSPeter Dunlap 	0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
846a6d42e7dSPeter Dunlap 	0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
847a6d42e7dSPeter Dunlap 	0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
848a6d42e7dSPeter Dunlap 	0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
849a6d42e7dSPeter Dunlap 	0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
850a6d42e7dSPeter Dunlap 	0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
851a6d42e7dSPeter Dunlap 	0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
852a6d42e7dSPeter Dunlap 	0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
853a6d42e7dSPeter Dunlap 	0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
854a6d42e7dSPeter Dunlap 	0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
855a6d42e7dSPeter Dunlap 	0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
856a6d42e7dSPeter Dunlap 	0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
857a6d42e7dSPeter Dunlap 	0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
858a6d42e7dSPeter Dunlap 	0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
859a6d42e7dSPeter Dunlap 	0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
860a6d42e7dSPeter Dunlap 	0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
861a6d42e7dSPeter Dunlap 	0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
862a6d42e7dSPeter Dunlap 	0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
863a6d42e7dSPeter Dunlap 	0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
864a6d42e7dSPeter Dunlap 	0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
865a6d42e7dSPeter Dunlap 	0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
866a6d42e7dSPeter Dunlap 	0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
867a6d42e7dSPeter Dunlap 	0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
868a6d42e7dSPeter Dunlap 	0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
869a6d42e7dSPeter Dunlap 	0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
870a6d42e7dSPeter Dunlap 	0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
871a6d42e7dSPeter Dunlap 	0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
872a6d42e7dSPeter Dunlap 	0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
873a6d42e7dSPeter Dunlap 	0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
874a6d42e7dSPeter Dunlap 	0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
875a6d42e7dSPeter Dunlap 	0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
876a6d42e7dSPeter Dunlap 	0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
877a6d42e7dSPeter Dunlap 	0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
878a6d42e7dSPeter Dunlap 	0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
879a6d42e7dSPeter Dunlap 	0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
880a6d42e7dSPeter Dunlap 	0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
881a6d42e7dSPeter Dunlap 	0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
882a6d42e7dSPeter Dunlap 	0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
883a6d42e7dSPeter Dunlap 	0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
884a6d42e7dSPeter Dunlap 	0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
885a6d42e7dSPeter Dunlap 	0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
886a6d42e7dSPeter Dunlap 	0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
887a6d42e7dSPeter Dunlap 	0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
888a6d42e7dSPeter Dunlap 	0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
889a6d42e7dSPeter Dunlap 	0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
890a6d42e7dSPeter Dunlap 	0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
891a6d42e7dSPeter Dunlap 	0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
892a6d42e7dSPeter Dunlap 	0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
893a6d42e7dSPeter Dunlap 	0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
894a6d42e7dSPeter Dunlap 	0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
895a6d42e7dSPeter Dunlap 	0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
896a6d42e7dSPeter Dunlap 	0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
897a6d42e7dSPeter Dunlap 	0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
898a6d42e7dSPeter Dunlap 	0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
899a6d42e7dSPeter Dunlap 	0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
900a6d42e7dSPeter Dunlap 	0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
901a6d42e7dSPeter Dunlap 	0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
902a6d42e7dSPeter Dunlap 	0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
903a6d42e7dSPeter Dunlap };
904a6d42e7dSPeter Dunlap 
905a6d42e7dSPeter Dunlap /*
906a6d42e7dSPeter Dunlap  * iscsi_crc32c - Steps through buffer one byte at at time, calculates
907a6d42e7dSPeter Dunlap  * reflected crc using table.
908a6d42e7dSPeter Dunlap  */
909a6d42e7dSPeter Dunlap uint32_t
idm_crc32c(void * address,unsigned long length)910a6d42e7dSPeter Dunlap idm_crc32c(void *address, unsigned long length)
911a6d42e7dSPeter Dunlap {
912a6d42e7dSPeter Dunlap 	uint8_t *buffer = address;
913a6d42e7dSPeter Dunlap 	uint32_t crc = 0xffffffff, result;
914a6d42e7dSPeter Dunlap #ifdef _BIG_ENDIAN
915a6d42e7dSPeter Dunlap 	uint8_t byte0, byte1, byte2, byte3;
916a6d42e7dSPeter Dunlap #endif
917a6d42e7dSPeter Dunlap 
918a6d42e7dSPeter Dunlap 	ASSERT(address != NULL);
919a6d42e7dSPeter Dunlap 
920d4b0f847SJack Meng 	if (iscsi_crc32_hd == -1) {
921d4b0f847SJack Meng 		if (hd_crc32_avail((uint32_t *)idm_crc32c_table) == B_TRUE) {
922d4b0f847SJack Meng 			iscsi_crc32_hd = 0;
923d4b0f847SJack Meng 		} else {
924d4b0f847SJack Meng 			iscsi_crc32_hd = 1;
925d4b0f847SJack Meng 		}
926d4b0f847SJack Meng 	}
927d4b0f847SJack Meng 	if (iscsi_crc32_hd == 0)
928d4b0f847SJack Meng 		return (HW_CRC32(buffer, length, crc));
929d4b0f847SJack Meng 
930a6d42e7dSPeter Dunlap 	while (length--) {
931a6d42e7dSPeter Dunlap 		crc = idm_crc32c_table[(crc ^ *buffer++) & 0xFFL] ^
932a6d42e7dSPeter Dunlap 		    (crc >> 8);
933a6d42e7dSPeter Dunlap 	}
934a6d42e7dSPeter Dunlap 	result = crc ^ 0xffffffff;
935a6d42e7dSPeter Dunlap 
936a6d42e7dSPeter Dunlap #ifdef	_BIG_ENDIAN
937a6d42e7dSPeter Dunlap 	byte0 = (uint8_t)(result & 0xFF);
938a6d42e7dSPeter Dunlap 	byte1 = (uint8_t)((result >> 8) & 0xFF);
939a6d42e7dSPeter Dunlap 	byte2 = (uint8_t)((result >> 16) & 0xFF);
940a6d42e7dSPeter Dunlap 	byte3 = (uint8_t)((result >> 24) & 0xFF);
941a6d42e7dSPeter Dunlap 	result = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
942a6d42e7dSPeter Dunlap #endif	/* _BIG_ENDIAN */
943a6d42e7dSPeter Dunlap 
944a6d42e7dSPeter Dunlap 	return (result);
945a6d42e7dSPeter Dunlap }
946a6d42e7dSPeter Dunlap 
947a6d42e7dSPeter Dunlap 
948a6d42e7dSPeter Dunlap /*
949a6d42e7dSPeter Dunlap  * idm_crc32c_continued - Continues stepping through buffer one
950a6d42e7dSPeter Dunlap  * byte at at time, calculates reflected crc using table.
951a6d42e7dSPeter Dunlap  */
952a6d42e7dSPeter Dunlap uint32_t
idm_crc32c_continued(void * address,unsigned long length,uint32_t crc)953a6d42e7dSPeter Dunlap idm_crc32c_continued(void *address, unsigned long length, uint32_t crc)
954a6d42e7dSPeter Dunlap {
955a6d42e7dSPeter Dunlap 	uint8_t *buffer = address;
956a6d42e7dSPeter Dunlap 	uint32_t result;
957a6d42e7dSPeter Dunlap #ifdef	_BIG_ENDIAN
958a6d42e7dSPeter Dunlap 	uint8_t byte0, byte1, byte2, byte3;
959a6d42e7dSPeter Dunlap #endif
960a6d42e7dSPeter Dunlap 
961a6d42e7dSPeter Dunlap 	ASSERT(address != NULL);
962a6d42e7dSPeter Dunlap 
963d4b0f847SJack Meng 	if (iscsi_crc32_hd == -1) {
964d4b0f847SJack Meng 		if (hd_crc32_avail((uint32_t *)idm_crc32c_table) == B_TRUE) {
965d4b0f847SJack Meng 			iscsi_crc32_hd = 0;
966d4b0f847SJack Meng 		} else {
967d4b0f847SJack Meng 			iscsi_crc32_hd = 1;
968d4b0f847SJack Meng 		}
969d4b0f847SJack Meng 	}
970d4b0f847SJack Meng 	if (iscsi_crc32_hd == 0)
971d4b0f847SJack Meng 		return (HW_CRC32_CONT(buffer, length, crc));
972d4b0f847SJack Meng 
973d4b0f847SJack Meng 
974a6d42e7dSPeter Dunlap #ifdef	_BIG_ENDIAN
975a6d42e7dSPeter Dunlap 	byte0 = (uint8_t)((crc >> 24) & 0xFF);
976a6d42e7dSPeter Dunlap 	byte1 = (uint8_t)((crc >> 16) & 0xFF);
977a6d42e7dSPeter Dunlap 	byte2 = (uint8_t)((crc >> 8) & 0xFF);
978a6d42e7dSPeter Dunlap 	byte3 = (uint8_t)(crc & 0xFF);
979a6d42e7dSPeter Dunlap 	crc = ((byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0);