xref: /freebsd/sys/dev/iscsi/iscsi.c (revision 4f0f5bf99591ad9907822082270523ac919e3b8c)
1009ea47eSEdward Tomasz Napierala /*-
2718cf2ccSPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3718cf2ccSPedro F. Giffuni  *
4009ea47eSEdward Tomasz Napierala  * Copyright (c) 2012 The FreeBSD Foundation
5009ea47eSEdward Tomasz Napierala  *
6009ea47eSEdward Tomasz Napierala  * This software was developed by Edward Tomasz Napierala under sponsorship
7009ea47eSEdward Tomasz Napierala  * from the FreeBSD Foundation.
8009ea47eSEdward Tomasz Napierala  *
9009ea47eSEdward Tomasz Napierala  * Redistribution and use in source and binary forms, with or without
10009ea47eSEdward Tomasz Napierala  * modification, are permitted provided that the following conditions
11009ea47eSEdward Tomasz Napierala  * are met:
12009ea47eSEdward Tomasz Napierala  * 1. Redistributions of source code must retain the above copyright
13009ea47eSEdward Tomasz Napierala  *    notice, this list of conditions and the following disclaimer.
14009ea47eSEdward Tomasz Napierala  * 2. Redistributions in binary form must reproduce the above copyright
15009ea47eSEdward Tomasz Napierala  *    notice, this list of conditions and the following disclaimer in the
16009ea47eSEdward Tomasz Napierala  *    documentation and/or other materials provided with the distribution.
17009ea47eSEdward Tomasz Napierala  *
18009ea47eSEdward Tomasz Napierala  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19009ea47eSEdward Tomasz Napierala  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20009ea47eSEdward Tomasz Napierala  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21009ea47eSEdward Tomasz Napierala  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22009ea47eSEdward Tomasz Napierala  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23009ea47eSEdward Tomasz Napierala  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24009ea47eSEdward Tomasz Napierala  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25009ea47eSEdward Tomasz Napierala  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26009ea47eSEdward Tomasz Napierala  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27009ea47eSEdward Tomasz Napierala  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28009ea47eSEdward Tomasz Napierala  * SUCH DAMAGE.
29009ea47eSEdward Tomasz Napierala  *
30009ea47eSEdward Tomasz Napierala  */
31009ea47eSEdward Tomasz Napierala 
32b7a65e39SEdward Tomasz Napierala #include <sys/cdefs.h>
33b7a65e39SEdward Tomasz Napierala __FBSDID("$FreeBSD$");
34b7a65e39SEdward Tomasz Napierala 
35009ea47eSEdward Tomasz Napierala #include <sys/param.h>
36009ea47eSEdward Tomasz Napierala #include <sys/condvar.h>
37009ea47eSEdward Tomasz Napierala #include <sys/conf.h>
38a9f2f291SEdward Tomasz Napierala #include <sys/endian.h>
39009ea47eSEdward Tomasz Napierala #include <sys/eventhandler.h>
40009ea47eSEdward Tomasz Napierala #include <sys/file.h>
41009ea47eSEdward Tomasz Napierala #include <sys/kernel.h>
42009ea47eSEdward Tomasz Napierala #include <sys/kthread.h>
43009ea47eSEdward Tomasz Napierala #include <sys/lock.h>
44009ea47eSEdward Tomasz Napierala #include <sys/malloc.h>
45009ea47eSEdward Tomasz Napierala #include <sys/mutex.h>
46009ea47eSEdward Tomasz Napierala #include <sys/module.h>
47f41492b0SEdward Tomasz Napierala #include <sys/socket.h>
48009ea47eSEdward Tomasz Napierala #include <sys/sysctl.h>
49009ea47eSEdward Tomasz Napierala #include <sys/systm.h>
50009ea47eSEdward Tomasz Napierala #include <sys/sx.h>
51009ea47eSEdward Tomasz Napierala #include <vm/uma.h>
52009ea47eSEdward Tomasz Napierala 
53009ea47eSEdward Tomasz Napierala #include <cam/cam.h>
54009ea47eSEdward Tomasz Napierala #include <cam/cam_ccb.h>
55009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt.h>
56009ea47eSEdward Tomasz Napierala #include <cam/cam_debug.h>
57009ea47eSEdward Tomasz Napierala #include <cam/cam_sim.h>
58009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt_sim.h>
59009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt_periph.h>
60009ea47eSEdward Tomasz Napierala #include <cam/cam_periph.h>
61009ea47eSEdward Tomasz Napierala #include <cam/scsi/scsi_all.h>
62009ea47eSEdward Tomasz Napierala #include <cam/scsi/scsi_message.h>
63009ea47eSEdward Tomasz Napierala 
64ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/icl.h>
65321b17ecSEdward Tomasz Napierala #include <dev/iscsi/icl_wrappers.h>
66ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi_ioctl.h>
67ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi_proto.h>
68ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi.h>
69009ea47eSEdward Tomasz Napierala 
70009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
71009ea47eSEdward Tomasz Napierala #include <sys/socketvar.h>
72009ea47eSEdward Tomasz Napierala #endif
73009ea47eSEdward Tomasz Napierala 
742ebde326SEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
752ebde326SEdward Tomasz Napierala FEATURE(iscsi_kernel_proxy, "iSCSI initiator built with ICL_KERNEL_PROXY");
762ebde326SEdward Tomasz Napierala #endif
772ebde326SEdward Tomasz Napierala 
78009ea47eSEdward Tomasz Napierala /*
79009ea47eSEdward Tomasz Napierala  * XXX: This is global so the iscsi_unload() can access it.
80009ea47eSEdward Tomasz Napierala  * 	Think about how to do this properly.
81009ea47eSEdward Tomasz Napierala  */
82009ea47eSEdward Tomasz Napierala static struct iscsi_softc	*sc;
83009ea47eSEdward Tomasz Napierala 
84e0d69c5aSPawel Biernacki SYSCTL_NODE(_kern, OID_AUTO, iscsi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
85e0d69c5aSPawel Biernacki     "iSCSI initiator");
86009ea47eSEdward Tomasz Napierala static int debug = 1;
87605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, debug, CTLFLAG_RWTUN,
881f6b2af2SAlexander Motin     &debug, 0, "Enable debug messages");
89009ea47eSEdward Tomasz Napierala static int ping_timeout = 5;
90605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, ping_timeout, CTLFLAG_RWTUN, &ping_timeout,
911f6b2af2SAlexander Motin     0, "Timeout for ping (NOP-Out) requests, in seconds");
92009ea47eSEdward Tomasz Napierala static int iscsid_timeout = 60;
93605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, iscsid_timeout, CTLFLAG_RWTUN, &iscsid_timeout,
941f6b2af2SAlexander Motin     0, "Time to wait for iscsid(8) to handle reconnection, in seconds");
95009ea47eSEdward Tomasz Napierala static int login_timeout = 60;
96605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, login_timeout, CTLFLAG_RWTUN, &login_timeout,
971f6b2af2SAlexander Motin     0, "Time to wait for iscsid(8) to finish Login Phase, in seconds");
98009ea47eSEdward Tomasz Napierala static int maxtags = 255;
99605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, maxtags, CTLFLAG_RWTUN, &maxtags,
1001f6b2af2SAlexander Motin     0, "Max number of IO requests queued");
101f1f12e40SEdward Tomasz Napierala static int fail_on_disconnection = 0;
102f1f12e40SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, fail_on_disconnection, CTLFLAG_RWTUN,
103f1f12e40SEdward Tomasz Napierala     &fail_on_disconnection, 0, "Destroy CAM SIM on connection failure");
104481b36c6SSteven Hartland static int fail_on_shutdown = 1;
105481b36c6SSteven Hartland SYSCTL_INT(_kern_iscsi, OID_AUTO, fail_on_shutdown, CTLFLAG_RWTUN,
106481b36c6SSteven Hartland     &fail_on_shutdown, 0, "Fail disconnected sessions on shutdown");
107009ea47eSEdward Tomasz Napierala 
108009ea47eSEdward Tomasz Napierala static MALLOC_DEFINE(M_ISCSI, "iSCSI", "iSCSI initiator");
109009ea47eSEdward Tomasz Napierala static uma_zone_t iscsi_outstanding_zone;
110009ea47eSEdward Tomasz Napierala 
111009ea47eSEdward Tomasz Napierala #define	CONN_SESSION(X)	((struct iscsi_session *)X->ic_prv0)
112009ea47eSEdward Tomasz Napierala #define	PDU_SESSION(X)	(CONN_SESSION(X->ip_conn))
113009ea47eSEdward Tomasz Napierala 
114009ea47eSEdward Tomasz Napierala #define	ISCSI_DEBUG(X, ...)						\
115b1277ad1SEdward Tomasz Napierala 	do {								\
116b1277ad1SEdward Tomasz Napierala 		if (debug > 1) 						\
117009ea47eSEdward Tomasz Napierala 			printf("%s: " X "\n", __func__, ## __VA_ARGS__);\
118009ea47eSEdward Tomasz Napierala 	} while (0)
119009ea47eSEdward Tomasz Napierala 
120009ea47eSEdward Tomasz Napierala #define	ISCSI_WARN(X, ...)						\
121b1277ad1SEdward Tomasz Napierala 	do {								\
122009ea47eSEdward Tomasz Napierala 		if (debug > 0) {					\
123009ea47eSEdward Tomasz Napierala 			printf("WARNING: %s: " X "\n",			\
124009ea47eSEdward Tomasz Napierala 			    __func__, ## __VA_ARGS__);			\
125b1277ad1SEdward Tomasz Napierala 		}							\
126009ea47eSEdward Tomasz Napierala 	} while (0)
127009ea47eSEdward Tomasz Napierala 
128009ea47eSEdward Tomasz Napierala #define	ISCSI_SESSION_DEBUG(S, X, ...)					\
129b1277ad1SEdward Tomasz Napierala 	do {								\
130009ea47eSEdward Tomasz Napierala 		if (debug > 1) {					\
131009ea47eSEdward Tomasz Napierala 			printf("%s: %s (%s): " X "\n",			\
132009ea47eSEdward Tomasz Napierala 			    __func__, S->is_conf.isc_target_addr,	\
133009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target, ## __VA_ARGS__);	\
134b1277ad1SEdward Tomasz Napierala 		}							\
135009ea47eSEdward Tomasz Napierala 	} while (0)
136009ea47eSEdward Tomasz Napierala 
137009ea47eSEdward Tomasz Napierala #define	ISCSI_SESSION_WARN(S, X, ...)					\
138b1277ad1SEdward Tomasz Napierala 	do {								\
139009ea47eSEdward Tomasz Napierala 		if (debug > 0) {					\
140009ea47eSEdward Tomasz Napierala 			printf("WARNING: %s (%s): " X "\n",		\
141009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target_addr,			\
142009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target, ## __VA_ARGS__);	\
143b1277ad1SEdward Tomasz Napierala 		}							\
144009ea47eSEdward Tomasz Napierala 	} while (0)
145009ea47eSEdward Tomasz Napierala 
146009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_LOCK(X)		mtx_lock(&X->is_lock)
147009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_UNLOCK(X)		mtx_unlock(&X->is_lock)
148009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_LOCK_ASSERT(X)	mtx_assert(&X->is_lock, MA_OWNED)
149c215ad3aSAlexander Motin #define ISCSI_SESSION_LOCK_ASSERT_NOT(X) mtx_assert(&X->is_lock, MA_NOTOWNED)
150009ea47eSEdward Tomasz Napierala 
151009ea47eSEdward Tomasz Napierala static int	iscsi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg,
152009ea47eSEdward Tomasz Napierala 		    int mode, struct thread *td);
153009ea47eSEdward Tomasz Napierala 
154009ea47eSEdward Tomasz Napierala static struct cdevsw iscsi_cdevsw = {
155009ea47eSEdward Tomasz Napierala      .d_version = D_VERSION,
156009ea47eSEdward Tomasz Napierala      .d_ioctl   = iscsi_ioctl,
157009ea47eSEdward Tomasz Napierala      .d_name    = "iscsi",
158009ea47eSEdward Tomasz Napierala };
159009ea47eSEdward Tomasz Napierala 
160009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_queue_locked(struct icl_pdu *request);
161009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_queue(struct icl_pdu *request);
162009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_update_statsn(const struct icl_pdu *response);
163009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_nop_in(struct icl_pdu *response);
164009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_scsi_response(struct icl_pdu *response);
165aa75114cSAlexander Motin static void	iscsi_pdu_handle_task_response(struct icl_pdu *response);
166009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_data_in(struct icl_pdu *response);
167009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_logout_response(struct icl_pdu *response);
168009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_r2t(struct icl_pdu *response);
169009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_async_message(struct icl_pdu *response);
170009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_reject(struct icl_pdu *response);
171009ea47eSEdward Tomasz Napierala static void	iscsi_session_reconnect(struct iscsi_session *is);
172009ea47eSEdward Tomasz Napierala static void	iscsi_session_terminate(struct iscsi_session *is);
173009ea47eSEdward Tomasz Napierala static void	iscsi_action(struct cam_sim *sim, union ccb *ccb);
174009ea47eSEdward Tomasz Napierala static struct iscsi_outstanding	*iscsi_outstanding_find(struct iscsi_session *is,
175009ea47eSEdward Tomasz Napierala 		    uint32_t initiator_task_tag);
176aa75114cSAlexander Motin static struct iscsi_outstanding	*iscsi_outstanding_add(struct iscsi_session *is,
177604c023fSEdward Tomasz Napierala 		    struct icl_pdu *request, union ccb *ccb,
178604c023fSEdward Tomasz Napierala 		    uint32_t *initiator_task_tagp);
179009ea47eSEdward Tomasz Napierala static void	iscsi_outstanding_remove(struct iscsi_session *is,
180009ea47eSEdward Tomasz Napierala 		    struct iscsi_outstanding *io);
181009ea47eSEdward Tomasz Napierala 
182009ea47eSEdward Tomasz Napierala static bool
183009ea47eSEdward Tomasz Napierala iscsi_pdu_prepare(struct icl_pdu *request)
184009ea47eSEdward Tomasz Napierala {
185009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
186009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_command *bhssc;
187009ea47eSEdward Tomasz Napierala 
188009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
189009ea47eSEdward Tomasz Napierala 
190009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
191009ea47eSEdward Tomasz Napierala 
192009ea47eSEdward Tomasz Napierala 	/*
193009ea47eSEdward Tomasz Napierala 	 * We're only using fields common for all the request
194009ea47eSEdward Tomasz Napierala 	 * (initiator -> target) PDUs.
195009ea47eSEdward Tomasz Napierala 	 */
196009ea47eSEdward Tomasz Napierala 	bhssc = (struct iscsi_bhs_scsi_command *)request->ip_bhs;
197009ea47eSEdward Tomasz Napierala 
198009ea47eSEdward Tomasz Napierala 	/*
199009ea47eSEdward Tomasz Napierala 	 * Data-Out PDU does not contain CmdSN.
200009ea47eSEdward Tomasz Napierala 	 */
201009ea47eSEdward Tomasz Napierala 	if (bhssc->bhssc_opcode != ISCSI_BHS_OPCODE_SCSI_DATA_OUT) {
2022124e3b0SAlexander Motin 		if (ISCSI_SNGT(is->is_cmdsn, is->is_maxcmdsn) &&
203009ea47eSEdward Tomasz Napierala 		    (bhssc->bhssc_opcode & ISCSI_BHS_OPCODE_IMMEDIATE) == 0) {
204009ea47eSEdward Tomasz Napierala 			/*
205009ea47eSEdward Tomasz Napierala 			 * Current MaxCmdSN prevents us from sending any more
206009ea47eSEdward Tomasz Napierala 			 * SCSI Command PDUs to the target; postpone the PDU.
207009ea47eSEdward Tomasz Napierala 			 * It will get resent by either iscsi_pdu_queue(),
208009ea47eSEdward Tomasz Napierala 			 * or by maintenance thread.
209009ea47eSEdward Tomasz Napierala 			 */
210009ea47eSEdward Tomasz Napierala #if 0
2112124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is, "postponing send, CmdSN %u, "
2122124e3b0SAlexander Motin 			    "ExpCmdSN %u, MaxCmdSN %u, opcode 0x%x",
2132124e3b0SAlexander Motin 			    is->is_cmdsn, is->is_expcmdsn, is->is_maxcmdsn,
2142124e3b0SAlexander Motin 			    bhssc->bhssc_opcode);
215009ea47eSEdward Tomasz Napierala #endif
216009ea47eSEdward Tomasz Napierala 			return (true);
217009ea47eSEdward Tomasz Napierala 		}
218009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_cmdsn = htonl(is->is_cmdsn);
219009ea47eSEdward Tomasz Napierala 		if ((bhssc->bhssc_opcode & ISCSI_BHS_OPCODE_IMMEDIATE) == 0)
220009ea47eSEdward Tomasz Napierala 			is->is_cmdsn++;
221009ea47eSEdward Tomasz Napierala 	}
222009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_expstatsn = htonl(is->is_statsn + 1);
223009ea47eSEdward Tomasz Napierala 
224009ea47eSEdward Tomasz Napierala 	return (false);
225009ea47eSEdward Tomasz Napierala }
226009ea47eSEdward Tomasz Napierala 
227009ea47eSEdward Tomasz Napierala static void
228009ea47eSEdward Tomasz Napierala iscsi_session_send_postponed(struct iscsi_session *is)
229009ea47eSEdward Tomasz Napierala {
230009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
231009ea47eSEdward Tomasz Napierala 	bool postpone;
232009ea47eSEdward Tomasz Napierala 
233009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
234009ea47eSEdward Tomasz Napierala 
2354c9ea0ceSAlexander Motin 	if (STAILQ_EMPTY(&is->is_postponed))
2364c9ea0ceSAlexander Motin 		return;
2374c9ea0ceSAlexander Motin 	while ((request = STAILQ_FIRST(&is->is_postponed)) != NULL) {
238009ea47eSEdward Tomasz Napierala 		postpone = iscsi_pdu_prepare(request);
239009ea47eSEdward Tomasz Napierala 		if (postpone)
2404c9ea0ceSAlexander Motin 			return;
24116c158a5SEdward Tomasz Napierala 		STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
242009ea47eSEdward Tomasz Napierala 		icl_pdu_queue(request);
243009ea47eSEdward Tomasz Napierala 	}
2444c9ea0ceSAlexander Motin 	xpt_release_simq(is->is_sim, 1);
245009ea47eSEdward Tomasz Napierala }
246009ea47eSEdward Tomasz Napierala 
247009ea47eSEdward Tomasz Napierala static void
248009ea47eSEdward Tomasz Napierala iscsi_pdu_queue_locked(struct icl_pdu *request)
249009ea47eSEdward Tomasz Napierala {
250009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
251009ea47eSEdward Tomasz Napierala 	bool postpone;
252009ea47eSEdward Tomasz Napierala 
253009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
254009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
255009ea47eSEdward Tomasz Napierala 	iscsi_session_send_postponed(is);
256009ea47eSEdward Tomasz Napierala 	postpone = iscsi_pdu_prepare(request);
257009ea47eSEdward Tomasz Napierala 	if (postpone) {
2584c9ea0ceSAlexander Motin 		if (STAILQ_EMPTY(&is->is_postponed))
2594c9ea0ceSAlexander Motin 			xpt_freeze_simq(is->is_sim, 1);
26016c158a5SEdward Tomasz Napierala 		STAILQ_INSERT_TAIL(&is->is_postponed, request, ip_next);
261009ea47eSEdward Tomasz Napierala 		return;
262009ea47eSEdward Tomasz Napierala 	}
263009ea47eSEdward Tomasz Napierala 	icl_pdu_queue(request);
264009ea47eSEdward Tomasz Napierala }
265009ea47eSEdward Tomasz Napierala 
266009ea47eSEdward Tomasz Napierala static void
267009ea47eSEdward Tomasz Napierala iscsi_pdu_queue(struct icl_pdu *request)
268009ea47eSEdward Tomasz Napierala {
269009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
270009ea47eSEdward Tomasz Napierala 
271009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
272009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
273009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
274009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
275009ea47eSEdward Tomasz Napierala }
276009ea47eSEdward Tomasz Napierala 
277009ea47eSEdward Tomasz Napierala static void
278009ea47eSEdward Tomasz Napierala iscsi_session_logout(struct iscsi_session *is)
279009ea47eSEdward Tomasz Napierala {
280009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
281009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_logout_request *bhslr;
282009ea47eSEdward Tomasz Napierala 
283d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
284009ea47eSEdward Tomasz Napierala 	if (request == NULL)
285009ea47eSEdward Tomasz Napierala 		return;
286009ea47eSEdward Tomasz Napierala 
287009ea47eSEdward Tomasz Napierala 	bhslr = (struct iscsi_bhs_logout_request *)request->ip_bhs;
288009ea47eSEdward Tomasz Napierala 	bhslr->bhslr_opcode = ISCSI_BHS_OPCODE_LOGOUT_REQUEST;
289009ea47eSEdward Tomasz Napierala 	bhslr->bhslr_reason = BHSLR_REASON_CLOSE_SESSION;
290009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
291009ea47eSEdward Tomasz Napierala }
292009ea47eSEdward Tomasz Napierala 
293009ea47eSEdward Tomasz Napierala static void
294aa75114cSAlexander Motin iscsi_session_terminate_task(struct iscsi_session *is,
295ad10496cSAndriy Gapon     struct iscsi_outstanding *io, cam_status status)
296aa75114cSAlexander Motin {
297aa75114cSAlexander Motin 
298e204e2cdSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
299e204e2cdSEdward Tomasz Napierala 
300aa75114cSAlexander Motin 	if (io->io_ccb != NULL) {
301aa75114cSAlexander Motin 		io->io_ccb->ccb_h.status &= ~(CAM_SIM_QUEUED | CAM_STATUS_MASK);
302ad10496cSAndriy Gapon 		io->io_ccb->ccb_h.status |= status;
303aa75114cSAlexander Motin 		if ((io->io_ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
304aa75114cSAlexander Motin 			io->io_ccb->ccb_h.status |= CAM_DEV_QFRZN;
305aa75114cSAlexander Motin 			xpt_freeze_devq(io->io_ccb->ccb_h.path, 1);
306aa75114cSAlexander Motin 			ISCSI_SESSION_DEBUG(is, "freezing devq");
307aa75114cSAlexander Motin 		}
308aa75114cSAlexander Motin 		xpt_done(io->io_ccb);
309aa75114cSAlexander Motin 	}
310aa75114cSAlexander Motin 	iscsi_outstanding_remove(is, io);
311aa75114cSAlexander Motin }
312aa75114cSAlexander Motin 
313aa75114cSAlexander Motin static void
314ad10496cSAndriy Gapon iscsi_session_terminate_tasks(struct iscsi_session *is, cam_status status)
315009ea47eSEdward Tomasz Napierala {
316009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io, *tmp;
317009ea47eSEdward Tomasz Napierala 
318009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
319009ea47eSEdward Tomasz Napierala 
320009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH_SAFE(io, &is->is_outstanding, io_next, tmp) {
321ad10496cSAndriy Gapon 		iscsi_session_terminate_task(is, io, status);
322009ea47eSEdward Tomasz Napierala 	}
323009ea47eSEdward Tomasz Napierala }
324009ea47eSEdward Tomasz Napierala 
325009ea47eSEdward Tomasz Napierala static void
326f1f12e40SEdward Tomasz Napierala iscsi_session_cleanup(struct iscsi_session *is, bool destroy_sim)
327009ea47eSEdward Tomasz Napierala {
328009ea47eSEdward Tomasz Napierala 	struct icl_pdu *pdu;
329009ea47eSEdward Tomasz Napierala 
330f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
331009ea47eSEdward Tomasz Napierala 
332009ea47eSEdward Tomasz Napierala 	/*
333009ea47eSEdward Tomasz Napierala 	 * Don't queue any new PDUs.
334009ea47eSEdward Tomasz Napierala 	 */
335009ea47eSEdward Tomasz Napierala 	if (is->is_sim != NULL && is->is_simq_frozen == false) {
336009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "freezing");
337009ea47eSEdward Tomasz Napierala 		xpt_freeze_simq(is->is_sim, 1);
338009ea47eSEdward Tomasz Napierala 		is->is_simq_frozen = true;
339009ea47eSEdward Tomasz Napierala 	}
340009ea47eSEdward Tomasz Napierala 
341009ea47eSEdward Tomasz Napierala 	/*
342009ea47eSEdward Tomasz Napierala 	 * Remove postponed PDUs.
343009ea47eSEdward Tomasz Napierala 	 */
3444c9ea0ceSAlexander Motin 	if (!STAILQ_EMPTY(&is->is_postponed))
3454c9ea0ceSAlexander Motin 		xpt_release_simq(is->is_sim, 1);
3464c9ea0ceSAlexander Motin 	while ((pdu = STAILQ_FIRST(&is->is_postponed)) != NULL) {
34716c158a5SEdward Tomasz Napierala 		STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
348009ea47eSEdward Tomasz Napierala 		icl_pdu_free(pdu);
349009ea47eSEdward Tomasz Napierala 	}
350009ea47eSEdward Tomasz Napierala 
351f1f12e40SEdward Tomasz Napierala 	if (destroy_sim == false) {
352009ea47eSEdward Tomasz Napierala 		/*
353009ea47eSEdward Tomasz Napierala 		 * Terminate SCSI tasks, asking CAM to requeue them.
354009ea47eSEdward Tomasz Napierala 		 */
355ad10496cSAndriy Gapon 		iscsi_session_terminate_tasks(is, CAM_REQUEUE_REQ);
356f1f12e40SEdward Tomasz Napierala 		return;
357f1f12e40SEdward Tomasz Napierala 	}
358f1f12e40SEdward Tomasz Napierala 
359ad10496cSAndriy Gapon 	iscsi_session_terminate_tasks(is, CAM_DEV_NOT_THERE);
360f1f12e40SEdward Tomasz Napierala 
361f1f12e40SEdward Tomasz Napierala 	if (is->is_sim == NULL)
362f1f12e40SEdward Tomasz Napierala 		return;
363f1f12e40SEdward Tomasz Napierala 
364f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "deregistering SIM");
365f1f12e40SEdward Tomasz Napierala 	xpt_async(AC_LOST_DEVICE, is->is_path, NULL);
366f1f12e40SEdward Tomasz Napierala 
367f1f12e40SEdward Tomasz Napierala 	if (is->is_simq_frozen) {
368f1f12e40SEdward Tomasz Napierala 		is->is_simq_frozen = false;
369186bcdaaSEdward Tomasz Napierala 		xpt_release_simq(is->is_sim, 1);
370f1f12e40SEdward Tomasz Napierala 	}
371f1f12e40SEdward Tomasz Napierala 
372f1f12e40SEdward Tomasz Napierala 	xpt_free_path(is->is_path);
373f1f12e40SEdward Tomasz Napierala 	is->is_path = NULL;
374f1f12e40SEdward Tomasz Napierala 	xpt_bus_deregister(cam_sim_path(is->is_sim));
375f1f12e40SEdward Tomasz Napierala 	cam_sim_free(is->is_sim, TRUE /*free_devq*/);
376f1f12e40SEdward Tomasz Napierala 	is->is_sim = NULL;
377f1f12e40SEdward Tomasz Napierala 	is->is_devq = NULL;
378f1f12e40SEdward Tomasz Napierala }
379f1f12e40SEdward Tomasz Napierala 
380f1f12e40SEdward Tomasz Napierala static void
381f1f12e40SEdward Tomasz Napierala iscsi_maintenance_thread_reconnect(struct iscsi_session *is)
382f1f12e40SEdward Tomasz Napierala {
383f1f12e40SEdward Tomasz Napierala 
384f1f12e40SEdward Tomasz Napierala 	icl_conn_close(is->is_conn);
385f1f12e40SEdward Tomasz Napierala 
386f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
387f1f12e40SEdward Tomasz Napierala 
388f1f12e40SEdward Tomasz Napierala 	is->is_connected = false;
389f1f12e40SEdward Tomasz Napierala 	is->is_reconnecting = false;
390f1f12e40SEdward Tomasz Napierala 	is->is_login_phase = false;
391f1f12e40SEdward Tomasz Napierala 
392f1f12e40SEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
393f1f12e40SEdward Tomasz Napierala 	if (is->is_login_pdu != NULL) {
394f1f12e40SEdward Tomasz Napierala 		icl_pdu_free(is->is_login_pdu);
395f1f12e40SEdward Tomasz Napierala 		is->is_login_pdu = NULL;
396f1f12e40SEdward Tomasz Napierala 	}
397f1f12e40SEdward Tomasz Napierala 	cv_signal(&is->is_login_cv);
398f1f12e40SEdward Tomasz Napierala #endif
399f1f12e40SEdward Tomasz Napierala 
400f1f12e40SEdward Tomasz Napierala 	if (fail_on_disconnection) {
401f1f12e40SEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "connection failed, destroying devices");
402f1f12e40SEdward Tomasz Napierala 		iscsi_session_cleanup(is, true);
403f1f12e40SEdward Tomasz Napierala 	} else {
404f1f12e40SEdward Tomasz Napierala 		iscsi_session_cleanup(is, false);
405f1f12e40SEdward Tomasz Napierala 	}
406009ea47eSEdward Tomasz Napierala 
407009ea47eSEdward Tomasz Napierala 	KASSERT(TAILQ_EMPTY(&is->is_outstanding),
408009ea47eSEdward Tomasz Napierala 	    ("destroying session with active tasks"));
40916c158a5SEdward Tomasz Napierala 	KASSERT(STAILQ_EMPTY(&is->is_postponed),
410009ea47eSEdward Tomasz Napierala 	    ("destroying session with postponed PDUs"));
411009ea47eSEdward Tomasz Napierala 
412ba165a31SEdward Tomasz Napierala 	if (is->is_conf.isc_enable == 0 && is->is_conf.isc_discovery == 0) {
413ba165a31SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
414ba165a31SEdward Tomasz Napierala 		return;
415ba165a31SEdward Tomasz Napierala 	}
416ba165a31SEdward Tomasz Napierala 
417009ea47eSEdward Tomasz Napierala 	/*
418009ea47eSEdward Tomasz Napierala 	 * Request immediate reconnection from iscsid(8).
419009ea47eSEdward Tomasz Napierala 	 */
420009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "waking up iscsid(8)");
421009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = true;
422009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
423009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
424009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
425009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_softc->sc_cv);
426009ea47eSEdward Tomasz Napierala }
427009ea47eSEdward Tomasz Napierala 
428009ea47eSEdward Tomasz Napierala static void
429009ea47eSEdward Tomasz Napierala iscsi_maintenance_thread_terminate(struct iscsi_session *is)
430009ea47eSEdward Tomasz Napierala {
431009ea47eSEdward Tomasz Napierala 	struct iscsi_softc *sc;
432009ea47eSEdward Tomasz Napierala 
433009ea47eSEdward Tomasz Napierala 	sc = is->is_softc;
434009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
43520e9cab5SAndriy Gapon 	TAILQ_REMOVE(&sc->sc_sessions, is, is_next);
43620e9cab5SAndriy Gapon 	sx_xunlock(&sc->sc_lock);
437009ea47eSEdward Tomasz Napierala 
438009ea47eSEdward Tomasz Napierala 	icl_conn_close(is->is_conn);
439674074daSEdward Tomasz Napierala 	callout_drain(&is->is_callout);
440009ea47eSEdward Tomasz Napierala 
441009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
442009ea47eSEdward Tomasz Napierala 
443009ea47eSEdward Tomasz Napierala 	KASSERT(is->is_terminating, ("is_terminating == false"));
444009ea47eSEdward Tomasz Napierala 
445009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
446009ea47eSEdward Tomasz Napierala 	if (is->is_login_pdu != NULL) {
447009ea47eSEdward Tomasz Napierala 		icl_pdu_free(is->is_login_pdu);
448009ea47eSEdward Tomasz Napierala 		is->is_login_pdu = NULL;
449009ea47eSEdward Tomasz Napierala 	}
450009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_login_cv);
451009ea47eSEdward Tomasz Napierala #endif
452009ea47eSEdward Tomasz Napierala 
453f1f12e40SEdward Tomasz Napierala 	iscsi_session_cleanup(is, true);
454009ea47eSEdward Tomasz Napierala 
455009ea47eSEdward Tomasz Napierala 	KASSERT(TAILQ_EMPTY(&is->is_outstanding),
456009ea47eSEdward Tomasz Napierala 	    ("destroying session with active tasks"));
45716c158a5SEdward Tomasz Napierala 	KASSERT(STAILQ_EMPTY(&is->is_postponed),
458009ea47eSEdward Tomasz Napierala 	    ("destroying session with postponed PDUs"));
459009ea47eSEdward Tomasz Napierala 
460009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
461009ea47eSEdward Tomasz Napierala 
462009ea47eSEdward Tomasz Napierala 	icl_conn_free(is->is_conn);
463009ea47eSEdward Tomasz Napierala 	mtx_destroy(&is->is_lock);
464009ea47eSEdward Tomasz Napierala 	cv_destroy(&is->is_maintenance_cv);
465009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
466009ea47eSEdward Tomasz Napierala 	cv_destroy(&is->is_login_cv);
467009ea47eSEdward Tomasz Napierala #endif
468481b36c6SSteven Hartland 
469009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "terminated");
470009ea47eSEdward Tomasz Napierala 	free(is, M_ISCSI);
471009ea47eSEdward Tomasz Napierala 
472009ea47eSEdward Tomasz Napierala 	/*
473009ea47eSEdward Tomasz Napierala 	 * The iscsi_unload() routine might be waiting.
474009ea47eSEdward Tomasz Napierala 	 */
475009ea47eSEdward Tomasz Napierala 	cv_signal(&sc->sc_cv);
476009ea47eSEdward Tomasz Napierala }
477009ea47eSEdward Tomasz Napierala 
478009ea47eSEdward Tomasz Napierala static void
479009ea47eSEdward Tomasz Napierala iscsi_maintenance_thread(void *arg)
480009ea47eSEdward Tomasz Napierala {
4815b338bc0SAlexander Motin 	struct iscsi_session *is = arg;
482009ea47eSEdward Tomasz Napierala 
483009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
4845b338bc0SAlexander Motin 	for (;;) {
485009ea47eSEdward Tomasz Napierala 		if (is->is_reconnecting == false &&
486009ea47eSEdward Tomasz Napierala 		    is->is_terminating == false &&
4875b338bc0SAlexander Motin 		    (STAILQ_EMPTY(&is->is_postponed) ||
4885b338bc0SAlexander Motin 		     ISCSI_SNGT(is->is_cmdsn, is->is_maxcmdsn)))
489009ea47eSEdward Tomasz Napierala 			cv_wait(&is->is_maintenance_cv, &is->is_lock);
490009ea47eSEdward Tomasz Napierala 
491481b36c6SSteven Hartland 		/* Terminate supersedes reconnect. */
492009ea47eSEdward Tomasz Napierala 		if (is->is_terminating) {
493009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
494009ea47eSEdward Tomasz Napierala 			iscsi_maintenance_thread_terminate(is);
495009ea47eSEdward Tomasz Napierala 			kthread_exit();
496009ea47eSEdward Tomasz Napierala 			return;
497009ea47eSEdward Tomasz Napierala 		}
498009ea47eSEdward Tomasz Napierala 
499481b36c6SSteven Hartland 		if (is->is_reconnecting) {
500481b36c6SSteven Hartland 			ISCSI_SESSION_UNLOCK(is);
501481b36c6SSteven Hartland 			iscsi_maintenance_thread_reconnect(is);
5025b338bc0SAlexander Motin 			ISCSI_SESSION_LOCK(is);
503481b36c6SSteven Hartland 			continue;
504481b36c6SSteven Hartland 		}
505481b36c6SSteven Hartland 
506009ea47eSEdward Tomasz Napierala 		iscsi_session_send_postponed(is);
507009ea47eSEdward Tomasz Napierala 	}
5085b338bc0SAlexander Motin 	ISCSI_SESSION_UNLOCK(is);
509009ea47eSEdward Tomasz Napierala }
510009ea47eSEdward Tomasz Napierala 
511009ea47eSEdward Tomasz Napierala static void
512009ea47eSEdward Tomasz Napierala iscsi_session_reconnect(struct iscsi_session *is)
513009ea47eSEdward Tomasz Napierala {
514009ea47eSEdward Tomasz Napierala 
515009ea47eSEdward Tomasz Napierala 	/*
516009ea47eSEdward Tomasz Napierala 	 * XXX: We can't use locking here, because
517009ea47eSEdward Tomasz Napierala 	 * 	it's being called from various contexts.
518009ea47eSEdward Tomasz Napierala 	 * 	Hope it doesn't break anything.
519009ea47eSEdward Tomasz Napierala 	 */
520009ea47eSEdward Tomasz Napierala 	if (is->is_reconnecting)
521009ea47eSEdward Tomasz Napierala 		return;
522009ea47eSEdward Tomasz Napierala 
523009ea47eSEdward Tomasz Napierala 	is->is_reconnecting = true;
524009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_maintenance_cv);
525009ea47eSEdward Tomasz Napierala }
526009ea47eSEdward Tomasz Napierala 
527009ea47eSEdward Tomasz Napierala static void
528009ea47eSEdward Tomasz Napierala iscsi_session_terminate(struct iscsi_session *is)
529009ea47eSEdward Tomasz Napierala {
530674074daSEdward Tomasz Napierala 
531009ea47eSEdward Tomasz Napierala 	if (is->is_terminating)
532009ea47eSEdward Tomasz Napierala 		return;
533009ea47eSEdward Tomasz Napierala 
534009ea47eSEdward Tomasz Napierala 	is->is_terminating = true;
535009ea47eSEdward Tomasz Napierala 
536009ea47eSEdward Tomasz Napierala #if 0
537009ea47eSEdward Tomasz Napierala 	iscsi_session_logout(is);
538009ea47eSEdward Tomasz Napierala #endif
539009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_maintenance_cv);
540009ea47eSEdward Tomasz Napierala }
541009ea47eSEdward Tomasz Napierala 
542009ea47eSEdward Tomasz Napierala static void
543009ea47eSEdward Tomasz Napierala iscsi_callout(void *context)
544009ea47eSEdward Tomasz Napierala {
545009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
546009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_out *bhsno;
547009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
548009ea47eSEdward Tomasz Napierala 	bool reconnect_needed = false;
549009ea47eSEdward Tomasz Napierala 
550009ea47eSEdward Tomasz Napierala 	is = context;
551009ea47eSEdward Tomasz Napierala 
552674074daSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
553674074daSEdward Tomasz Napierala 	if (is->is_terminating) {
554674074daSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
555009ea47eSEdward Tomasz Napierala 		return;
556674074daSEdward Tomasz Napierala 	}
557009ea47eSEdward Tomasz Napierala 
558009ea47eSEdward Tomasz Napierala 	callout_schedule(&is->is_callout, 1 * hz);
559009ea47eSEdward Tomasz Napierala 
560ba165a31SEdward Tomasz Napierala 	if (is->is_conf.isc_enable == 0)
561ba165a31SEdward Tomasz Napierala 		goto out;
562ba165a31SEdward Tomasz Napierala 
563009ea47eSEdward Tomasz Napierala 	is->is_timeout++;
564009ea47eSEdward Tomasz Napierala 
565009ea47eSEdward Tomasz Napierala 	if (is->is_waiting_for_iscsid) {
5662c5b89e5SEdward Tomasz Napierala 		if (iscsid_timeout > 0 && is->is_timeout > iscsid_timeout) {
567009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "timed out waiting for iscsid(8) "
568009ea47eSEdward Tomasz Napierala 			    "for %d seconds; reconnecting",
569009ea47eSEdward Tomasz Napierala 			    is->is_timeout);
570009ea47eSEdward Tomasz Napierala 			reconnect_needed = true;
571009ea47eSEdward Tomasz Napierala 		}
572009ea47eSEdward Tomasz Napierala 		goto out;
573009ea47eSEdward Tomasz Napierala 	}
574009ea47eSEdward Tomasz Napierala 
575009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
5762c5b89e5SEdward Tomasz Napierala 		if (login_timeout > 0 && is->is_timeout > login_timeout) {
577009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "login timed out after %d seconds; "
578009ea47eSEdward Tomasz Napierala 			    "reconnecting", is->is_timeout);
579009ea47eSEdward Tomasz Napierala 			reconnect_needed = true;
580009ea47eSEdward Tomasz Napierala 		}
581009ea47eSEdward Tomasz Napierala 		goto out;
582009ea47eSEdward Tomasz Napierala 	}
583009ea47eSEdward Tomasz Napierala 
5842c5b89e5SEdward Tomasz Napierala 	if (ping_timeout <= 0) {
5852c5b89e5SEdward Tomasz Napierala 		/*
5862c5b89e5SEdward Tomasz Napierala 		 * Pings are disabled.  Don't send NOP-Out in this case.
5872c5b89e5SEdward Tomasz Napierala 		 * Reset the timeout, to avoid triggering reconnection,
5882c5b89e5SEdward Tomasz Napierala 		 * should the user decide to reenable them.
5892c5b89e5SEdward Tomasz Napierala 		 */
5902c5b89e5SEdward Tomasz Napierala 		is->is_timeout = 0;
5912c5b89e5SEdward Tomasz Napierala 		goto out;
5922c5b89e5SEdward Tomasz Napierala 	}
5932c5b89e5SEdward Tomasz Napierala 
594009ea47eSEdward Tomasz Napierala 	if (is->is_timeout >= ping_timeout) {
595009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "no ping reply (NOP-In) after %d seconds; "
596009ea47eSEdward Tomasz Napierala 		    "reconnecting", ping_timeout);
597009ea47eSEdward Tomasz Napierala 		reconnect_needed = true;
598009ea47eSEdward Tomasz Napierala 		goto out;
599009ea47eSEdward Tomasz Napierala 	}
600009ea47eSEdward Tomasz Napierala 
601009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
602009ea47eSEdward Tomasz Napierala 
603009ea47eSEdward Tomasz Napierala 	/*
604009ea47eSEdward Tomasz Napierala 	 * If the ping was reset less than one second ago - which means
605009ea47eSEdward Tomasz Napierala 	 * that we've received some PDU during the last second - assume
606009ea47eSEdward Tomasz Napierala 	 * the traffic flows correctly and don't bother sending a NOP-Out.
607009ea47eSEdward Tomasz Napierala 	 *
608009ea47eSEdward Tomasz Napierala 	 * (It's 2 - one for one second, and one for incrementing is_timeout
609009ea47eSEdward Tomasz Napierala 	 * earlier in this routine.)
610009ea47eSEdward Tomasz Napierala 	 */
611009ea47eSEdward Tomasz Napierala 	if (is->is_timeout < 2)
612009ea47eSEdward Tomasz Napierala 		return;
613009ea47eSEdward Tomasz Napierala 
614d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
61546aaea89SEdward Tomasz Napierala 	if (request == NULL) {
61646aaea89SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate PDU");
61746aaea89SEdward Tomasz Napierala 		return;
61846aaea89SEdward Tomasz Napierala 	}
619009ea47eSEdward Tomasz Napierala 	bhsno = (struct iscsi_bhs_nop_out *)request->ip_bhs;
620009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_opcode = ISCSI_BHS_OPCODE_NOP_OUT |
621009ea47eSEdward Tomasz Napierala 	    ISCSI_BHS_OPCODE_IMMEDIATE;
622009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_flags = 0x80;
623009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_target_transfer_tag = 0xffffffff;
624009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue(request);
625009ea47eSEdward Tomasz Napierala 	return;
626009ea47eSEdward Tomasz Napierala 
627009ea47eSEdward Tomasz Napierala out:
628481b36c6SSteven Hartland 	if (is->is_terminating) {
629481b36c6SSteven Hartland 		ISCSI_SESSION_UNLOCK(is);
630481b36c6SSteven Hartland 		return;
631481b36c6SSteven Hartland 	}
632481b36c6SSteven Hartland 
633009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
634009ea47eSEdward Tomasz Napierala 
635009ea47eSEdward Tomasz Napierala 	if (reconnect_needed)
636009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
637009ea47eSEdward Tomasz Napierala }
638009ea47eSEdward Tomasz Napierala 
639009ea47eSEdward Tomasz Napierala static void
640009ea47eSEdward Tomasz Napierala iscsi_pdu_update_statsn(const struct icl_pdu *response)
641009ea47eSEdward Tomasz Napierala {
642009ea47eSEdward Tomasz Napierala 	const struct iscsi_bhs_data_in *bhsdi;
643009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
6442124e3b0SAlexander Motin 	uint32_t expcmdsn, maxcmdsn, statsn;
645009ea47eSEdward Tomasz Napierala 
646009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
647009ea47eSEdward Tomasz Napierala 
648009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
649009ea47eSEdward Tomasz Napierala 
650009ea47eSEdward Tomasz Napierala 	/*
651009ea47eSEdward Tomasz Napierala 	 * We're only using fields common for all the response
652009ea47eSEdward Tomasz Napierala 	 * (target -> initiator) PDUs.
653009ea47eSEdward Tomasz Napierala 	 */
654009ea47eSEdward Tomasz Napierala 	bhsdi = (const struct iscsi_bhs_data_in *)response->ip_bhs;
655009ea47eSEdward Tomasz Napierala 	/*
656009ea47eSEdward Tomasz Napierala 	 * Ok, I lied.  In case of Data-In, "The fields StatSN, Status,
657009ea47eSEdward Tomasz Napierala 	 * and Residual Count only have meaningful content if the S bit
658009ea47eSEdward Tomasz Napierala 	 * is set to 1", so we also need to check the bit specific for
659009ea47eSEdward Tomasz Napierala 	 * Data-In PDU.
660009ea47eSEdward Tomasz Napierala 	 */
661009ea47eSEdward Tomasz Napierala 	if (bhsdi->bhsdi_opcode != ISCSI_BHS_OPCODE_SCSI_DATA_IN ||
662009ea47eSEdward Tomasz Napierala 	    (bhsdi->bhsdi_flags & BHSDI_FLAGS_S) != 0) {
6632124e3b0SAlexander Motin 		statsn = ntohl(bhsdi->bhsdi_statsn);
6642124e3b0SAlexander Motin 		if (statsn != is->is_statsn && statsn != (is->is_statsn + 1)) {
6652124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
6662124e3b0SAlexander Motin 			ISCSI_SESSION_WARN(is, "PDU 0x%x StatSN %u != "
6672124e3b0SAlexander Motin 			    "session ExpStatSN %u (or + 1); reconnecting",
6682124e3b0SAlexander Motin 			    bhsdi->bhsdi_opcode, statsn, is->is_statsn);
6692124e3b0SAlexander Motin 			iscsi_session_reconnect(is);
670009ea47eSEdward Tomasz Napierala 		}
6712124e3b0SAlexander Motin 		if (ISCSI_SNGT(statsn, is->is_statsn))
6722124e3b0SAlexander Motin 			is->is_statsn = statsn;
673009ea47eSEdward Tomasz Napierala 	}
674009ea47eSEdward Tomasz Napierala 
675009ea47eSEdward Tomasz Napierala 	expcmdsn = ntohl(bhsdi->bhsdi_expcmdsn);
676009ea47eSEdward Tomasz Napierala 	maxcmdsn = ntohl(bhsdi->bhsdi_maxcmdsn);
677009ea47eSEdward Tomasz Napierala 
6782124e3b0SAlexander Motin 	if (ISCSI_SNLT(maxcmdsn + 1, expcmdsn)) {
6792124e3b0SAlexander Motin 		ISCSI_SESSION_DEBUG(is,
6802124e3b0SAlexander Motin 		    "PDU MaxCmdSN %u + 1 < PDU ExpCmdSN %u; ignoring",
681009ea47eSEdward Tomasz Napierala 		    maxcmdsn, expcmdsn);
682009ea47eSEdward Tomasz Napierala 	} else {
6832124e3b0SAlexander Motin 		if (ISCSI_SNGT(maxcmdsn, is->is_maxcmdsn)) {
684009ea47eSEdward Tomasz Napierala 			is->is_maxcmdsn = maxcmdsn;
685009ea47eSEdward Tomasz Napierala 
686009ea47eSEdward Tomasz Napierala 			/*
687009ea47eSEdward Tomasz Napierala 			 * Command window increased; kick the maintanance thread
688009ea47eSEdward Tomasz Napierala 			 * to send out postponed commands.
689009ea47eSEdward Tomasz Napierala 			 */
69016c158a5SEdward Tomasz Napierala 			if (!STAILQ_EMPTY(&is->is_postponed))
691009ea47eSEdward Tomasz Napierala 				cv_signal(&is->is_maintenance_cv);
6922124e3b0SAlexander Motin 		} else if (ISCSI_SNLT(maxcmdsn, is->is_maxcmdsn)) {
6932124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
6942124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is,
6952124e3b0SAlexander Motin 			    "PDU MaxCmdSN %u < session MaxCmdSN %u; ignoring",
696009ea47eSEdward Tomasz Napierala 			    maxcmdsn, is->is_maxcmdsn);
697009ea47eSEdward Tomasz Napierala 		}
698009ea47eSEdward Tomasz Napierala 
6992124e3b0SAlexander Motin 		if (ISCSI_SNGT(expcmdsn, is->is_expcmdsn)) {
700009ea47eSEdward Tomasz Napierala 			is->is_expcmdsn = expcmdsn;
7012124e3b0SAlexander Motin 		} else if (ISCSI_SNLT(expcmdsn, is->is_expcmdsn)) {
7022124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
7032124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is,
7042124e3b0SAlexander Motin 			    "PDU ExpCmdSN %u < session ExpCmdSN %u; ignoring",
705009ea47eSEdward Tomasz Napierala 			    expcmdsn, is->is_expcmdsn);
706009ea47eSEdward Tomasz Napierala 		}
707009ea47eSEdward Tomasz Napierala 	}
708009ea47eSEdward Tomasz Napierala 
709009ea47eSEdward Tomasz Napierala 	/*
710009ea47eSEdward Tomasz Napierala 	 * Every incoming PDU - not just NOP-In - resets the ping timer.
711009ea47eSEdward Tomasz Napierala 	 * The purpose of the timeout is to reset the connection when it stalls;
712009ea47eSEdward Tomasz Napierala 	 * we don't want this to happen when NOP-In or NOP-Out ends up delayed
713009ea47eSEdward Tomasz Napierala 	 * in some queue.
714009ea47eSEdward Tomasz Napierala 	 */
715009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
716009ea47eSEdward Tomasz Napierala }
717009ea47eSEdward Tomasz Napierala 
718009ea47eSEdward Tomasz Napierala static void
719009ea47eSEdward Tomasz Napierala iscsi_receive_callback(struct icl_pdu *response)
720009ea47eSEdward Tomasz Napierala {
721009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
722009ea47eSEdward Tomasz Napierala 
723009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
724009ea47eSEdward Tomasz Napierala 
725009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
726009ea47eSEdward Tomasz Napierala 
727d66a906bSEdward Tomasz Napierala 	iscsi_pdu_update_statsn(response);
728d66a906bSEdward Tomasz Napierala 
729009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
730009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
731009ea47eSEdward Tomasz Napierala 		if (is->is_login_pdu == NULL)
732009ea47eSEdward Tomasz Napierala 			is->is_login_pdu = response;
733009ea47eSEdward Tomasz Napierala 		else
734009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
735009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
736009ea47eSEdward Tomasz Napierala 		cv_signal(&is->is_login_cv);
737009ea47eSEdward Tomasz Napierala 		return;
738009ea47eSEdward Tomasz Napierala 	}
739009ea47eSEdward Tomasz Napierala #endif
740009ea47eSEdward Tomasz Napierala 
741009ea47eSEdward Tomasz Napierala 	/*
742009ea47eSEdward Tomasz Napierala 	 * The handling routine is responsible for freeing the PDU
743009ea47eSEdward Tomasz Napierala 	 * when it's no longer needed.
744009ea47eSEdward Tomasz Napierala 	 */
745009ea47eSEdward Tomasz Napierala 	switch (response->ip_bhs->bhs_opcode) {
746009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_NOP_IN:
747009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_nop_in(response);
748c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
749009ea47eSEdward Tomasz Napierala 		break;
750009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_SCSI_RESPONSE:
751009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_scsi_response(response);
752c215ad3aSAlexander Motin 		/* Session lock dropped inside. */
753c215ad3aSAlexander Motin 		ISCSI_SESSION_LOCK_ASSERT_NOT(is);
754009ea47eSEdward Tomasz Napierala 		break;
755aa75114cSAlexander Motin 	case ISCSI_BHS_OPCODE_TASK_RESPONSE:
756aa75114cSAlexander Motin 		iscsi_pdu_handle_task_response(response);
757c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
758aa75114cSAlexander Motin 		break;
759009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_SCSI_DATA_IN:
760009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_data_in(response);
761c215ad3aSAlexander Motin 		/* Session lock dropped inside. */
762c215ad3aSAlexander Motin 		ISCSI_SESSION_LOCK_ASSERT_NOT(is);
763009ea47eSEdward Tomasz Napierala 		break;
764009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_LOGOUT_RESPONSE:
765009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_logout_response(response);
766c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
767009ea47eSEdward Tomasz Napierala 		break;
768009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_R2T:
769009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_r2t(response);
770c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
771009ea47eSEdward Tomasz Napierala 		break;
772009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_ASYNC_MESSAGE:
773009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_async_message(response);
774c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
775009ea47eSEdward Tomasz Napierala 		break;
776009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_REJECT:
777009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_reject(response);
778c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
779009ea47eSEdward Tomasz Napierala 		break;
780009ea47eSEdward Tomasz Napierala 	default:
781009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "received PDU with unsupported "
782009ea47eSEdward Tomasz Napierala 		    "opcode 0x%x; reconnecting",
783009ea47eSEdward Tomasz Napierala 		    response->ip_bhs->bhs_opcode);
784009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
785c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
786009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
787009ea47eSEdward Tomasz Napierala 	}
788009ea47eSEdward Tomasz Napierala }
789009ea47eSEdward Tomasz Napierala 
790009ea47eSEdward Tomasz Napierala static void
791009ea47eSEdward Tomasz Napierala iscsi_error_callback(struct icl_conn *ic)
792009ea47eSEdward Tomasz Napierala {
793009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
794009ea47eSEdward Tomasz Napierala 
795009ea47eSEdward Tomasz Napierala 	is = CONN_SESSION(ic);
796009ea47eSEdward Tomasz Napierala 
797009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_WARN(is, "connection error; reconnecting");
798009ea47eSEdward Tomasz Napierala 	iscsi_session_reconnect(is);
799009ea47eSEdward Tomasz Napierala }
800009ea47eSEdward Tomasz Napierala 
801009ea47eSEdward Tomasz Napierala static void
802009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_nop_in(struct icl_pdu *response)
803009ea47eSEdward Tomasz Napierala {
8041008ac5eSEdward Tomasz Napierala 	struct iscsi_session *is;
805009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_out *bhsno;
806009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_in *bhsni;
807009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
8081008ac5eSEdward Tomasz Napierala 	void *data = NULL;
8091008ac5eSEdward Tomasz Napierala 	size_t datasize;
8101008ac5eSEdward Tomasz Napierala 	int error;
811009ea47eSEdward Tomasz Napierala 
8121008ac5eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
813009ea47eSEdward Tomasz Napierala 	bhsni = (struct iscsi_bhs_nop_in *)response->ip_bhs;
814009ea47eSEdward Tomasz Napierala 
815009ea47eSEdward Tomasz Napierala 	if (bhsni->bhsni_target_transfer_tag == 0xffffffff) {
816009ea47eSEdward Tomasz Napierala 		/*
817009ea47eSEdward Tomasz Napierala 		 * Nothing to do; iscsi_pdu_update_statsn() already
818009ea47eSEdward Tomasz Napierala 		 * zeroed the timeout.
819009ea47eSEdward Tomasz Napierala 		 */
820009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
821009ea47eSEdward Tomasz Napierala 		return;
822009ea47eSEdward Tomasz Napierala 	}
823009ea47eSEdward Tomasz Napierala 
8241008ac5eSEdward Tomasz Napierala 	datasize = icl_pdu_data_segment_length(response);
8251008ac5eSEdward Tomasz Napierala 	if (datasize > 0) {
8261008ac5eSEdward Tomasz Napierala 		data = malloc(datasize, M_ISCSI, M_NOWAIT | M_ZERO);
8271008ac5eSEdward Tomasz Napierala 		if (data == NULL) {
8281008ac5eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8291008ac5eSEdward Tomasz Napierala 			    "reconnecting");
8301008ac5eSEdward Tomasz Napierala 			icl_pdu_free(response);
8311008ac5eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
8321008ac5eSEdward Tomasz Napierala 			return;
8331008ac5eSEdward Tomasz Napierala 		}
8341008ac5eSEdward Tomasz Napierala 		icl_pdu_get_data(response, 0, data, datasize);
8351008ac5eSEdward Tomasz Napierala 	}
8361008ac5eSEdward Tomasz Napierala 
837d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(response->ip_conn, M_NOWAIT);
838009ea47eSEdward Tomasz Napierala 	if (request == NULL) {
8391008ac5eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8401008ac5eSEdward Tomasz Napierala 		    "reconnecting");
8411008ac5eSEdward Tomasz Napierala 		free(data, M_ISCSI);
842009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
8431008ac5eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
844009ea47eSEdward Tomasz Napierala 		return;
845009ea47eSEdward Tomasz Napierala 	}
846009ea47eSEdward Tomasz Napierala 	bhsno = (struct iscsi_bhs_nop_out *)request->ip_bhs;
847009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_opcode = ISCSI_BHS_OPCODE_NOP_OUT |
848009ea47eSEdward Tomasz Napierala 	    ISCSI_BHS_OPCODE_IMMEDIATE;
849009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_flags = 0x80;
8501008ac5eSEdward Tomasz Napierala 	bhsno->bhsno_initiator_task_tag = 0xffffffff;
851009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_target_transfer_tag = bhsni->bhsni_target_transfer_tag;
8521008ac5eSEdward Tomasz Napierala 	if (datasize > 0) {
8531008ac5eSEdward Tomasz Napierala 		error = icl_pdu_append_data(request, data, datasize, M_NOWAIT);
8541008ac5eSEdward Tomasz Napierala 		if (error != 0) {
8551008ac5eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8561008ac5eSEdward Tomasz Napierala 			    "reconnecting");
8571008ac5eSEdward Tomasz Napierala 			free(data, M_ISCSI);
8581008ac5eSEdward Tomasz Napierala 			icl_pdu_free(request);
8591008ac5eSEdward Tomasz Napierala 			icl_pdu_free(response);
8601008ac5eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
8611008ac5eSEdward Tomasz Napierala 			return;
8621008ac5eSEdward Tomasz Napierala 		}
8631008ac5eSEdward Tomasz Napierala 		free(data, M_ISCSI);
8641008ac5eSEdward Tomasz Napierala 	}
865009ea47eSEdward Tomasz Napierala 
866009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
867009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
868009ea47eSEdward Tomasz Napierala }
869009ea47eSEdward Tomasz Napierala 
870009ea47eSEdward Tomasz Napierala static void
871009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_scsi_response(struct icl_pdu *response)
872009ea47eSEdward Tomasz Napierala {
873009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_response *bhssr;
874009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
875009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
87673e2e95dSAlexander Motin 	union ccb *ccb;
877009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
87873e2e95dSAlexander Motin 	size_t data_segment_len, received;
879009ea47eSEdward Tomasz Napierala 	uint16_t sense_len;
880bcec64bcSEdward Tomasz Napierala 	uint32_t resid;
881009ea47eSEdward Tomasz Napierala 
882009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
883009ea47eSEdward Tomasz Napierala 
884009ea47eSEdward Tomasz Napierala 	bhssr = (struct iscsi_bhs_scsi_response *)response->ip_bhs;
885009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhssr->bhssr_initiator_task_tag);
886aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
887009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhssr->bhssr_initiator_task_tag);
888009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
889009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
890c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
891009ea47eSEdward Tomasz Napierala 		return;
892009ea47eSEdward Tomasz Napierala 	}
893009ea47eSEdward Tomasz Napierala 
89473e2e95dSAlexander Motin 	ccb = io->io_ccb;
895*4f0f5bf9SJohn Baldwin 	if (ntohl(bhssr->bhssr_expdatasn) != io->io_datasn) {
896*4f0f5bf9SJohn Baldwin 		ISCSI_SESSION_WARN(is,
897*4f0f5bf9SJohn Baldwin 		    "ExpDataSN mismatch in SCSI Response (%u vs %u)",
898*4f0f5bf9SJohn Baldwin 		    ntohl(bhssr->bhssr_expdatasn), io->io_datasn);
899*4f0f5bf9SJohn Baldwin 		icl_pdu_free(response);
900*4f0f5bf9SJohn Baldwin 		iscsi_session_reconnect(is);
901*4f0f5bf9SJohn Baldwin 		ISCSI_SESSION_UNLOCK(is);
902*4f0f5bf9SJohn Baldwin 		return;
903*4f0f5bf9SJohn Baldwin 	}
904bcec64bcSEdward Tomasz Napierala 
905bcec64bcSEdward Tomasz Napierala 	/*
906bcec64bcSEdward Tomasz Napierala 	 * With iSER, after getting good response we can be sure
907bcec64bcSEdward Tomasz Napierala 	 * that all the data has been successfully transferred.
908bcec64bcSEdward Tomasz Napierala 	 */
909bcec64bcSEdward Tomasz Napierala 	if (is->is_conn->ic_iser) {
910bcec64bcSEdward Tomasz Napierala 		resid = ntohl(bhssr->bhssr_residual_count);
911bcec64bcSEdward Tomasz Napierala 		if (bhssr->bhssr_flags & BHSSR_FLAGS_RESIDUAL_UNDERFLOW) {
912bcec64bcSEdward Tomasz Napierala 			io->io_received = ccb->csio.dxfer_len - resid;
913bcec64bcSEdward Tomasz Napierala 		} else if (bhssr->bhssr_flags & BHSSR_FLAGS_RESIDUAL_OVERFLOW) {
914bcec64bcSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "overflow: target indicates %d", resid);
915bcec64bcSEdward Tomasz Napierala 		} else {
916bcec64bcSEdward Tomasz Napierala 			io->io_received = ccb->csio.dxfer_len;
917bcec64bcSEdward Tomasz Napierala 		}
918bcec64bcSEdward Tomasz Napierala 	}
919bcec64bcSEdward Tomasz Napierala 
92073e2e95dSAlexander Motin 	received = io->io_received;
921c215ad3aSAlexander Motin 	iscsi_outstanding_remove(is, io);
922c215ad3aSAlexander Motin 	ISCSI_SESSION_UNLOCK(is);
923c215ad3aSAlexander Motin 
924009ea47eSEdward Tomasz Napierala 	if (bhssr->bhssr_response != BHSSR_RESPONSE_COMMAND_COMPLETED) {
925009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "service response 0x%x", bhssr->bhssr_response);
92673e2e95dSAlexander Motin  		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
92773e2e95dSAlexander Motin  			xpt_freeze_devq(ccb->ccb_h.path, 1);
928009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
929009ea47eSEdward Tomasz Napierala 		}
93073e2e95dSAlexander Motin  		ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
931009ea47eSEdward Tomasz Napierala 	} else if (bhssr->bhssr_status == 0) {
93273e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
933009ea47eSEdward Tomasz Napierala 	} else {
93473e2e95dSAlexander Motin  		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
93573e2e95dSAlexander Motin  			xpt_freeze_devq(ccb->ccb_h.path, 1);
936009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
937009ea47eSEdward Tomasz Napierala 		}
93873e2e95dSAlexander Motin  		ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | CAM_DEV_QFRZN;
93973e2e95dSAlexander Motin 		ccb->csio.scsi_status = bhssr->bhssr_status;
940009ea47eSEdward Tomasz Napierala 	}
941009ea47eSEdward Tomasz Napierala 
94273e2e95dSAlexander Motin 	csio = &ccb->csio;
943009ea47eSEdward Tomasz Napierala 	data_segment_len = icl_pdu_data_segment_length(response);
944009ea47eSEdward Tomasz Napierala 	if (data_segment_len > 0) {
945009ea47eSEdward Tomasz Napierala 		if (data_segment_len < sizeof(sense_len)) {
946009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "truncated data segment (%zd bytes)",
947009ea47eSEdward Tomasz Napierala 			    data_segment_len);
94873e2e95dSAlexander Motin 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
94973e2e95dSAlexander Motin 				xpt_freeze_devq(ccb->ccb_h.path, 1);
950009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
951009ea47eSEdward Tomasz Napierala 			}
95273e2e95dSAlexander Motin 			ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
953009ea47eSEdward Tomasz Napierala 			goto out;
954009ea47eSEdward Tomasz Napierala 		}
955009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(response, 0, &sense_len, sizeof(sense_len));
956009ea47eSEdward Tomasz Napierala 		sense_len = ntohs(sense_len);
957009ea47eSEdward Tomasz Napierala #if 0
958009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "sense_len %d, data len %zd",
959009ea47eSEdward Tomasz Napierala 		    sense_len, data_segment_len);
960009ea47eSEdward Tomasz Napierala #endif
961009ea47eSEdward Tomasz Napierala 		if (sizeof(sense_len) + sense_len > data_segment_len) {
962009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "truncated data segment "
963009ea47eSEdward Tomasz Napierala 			    "(%zd bytes, should be %zd)",
964009ea47eSEdward Tomasz Napierala 			    data_segment_len, sizeof(sense_len) + sense_len);
96573e2e95dSAlexander Motin 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
96673e2e95dSAlexander Motin 				xpt_freeze_devq(ccb->ccb_h.path, 1);
967009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
968009ea47eSEdward Tomasz Napierala 			}
96973e2e95dSAlexander Motin 			ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
970009ea47eSEdward Tomasz Napierala 			goto out;
971009ea47eSEdward Tomasz Napierala 		} else if (sizeof(sense_len) + sense_len < data_segment_len)
972009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "oversize data segment "
973009ea47eSEdward Tomasz Napierala 			    "(%zd bytes, should be %zd)",
974009ea47eSEdward Tomasz Napierala 			    data_segment_len, sizeof(sense_len) + sense_len);
975009ea47eSEdward Tomasz Napierala 		if (sense_len > csio->sense_len) {
976009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "truncating sense from %d to %d",
977009ea47eSEdward Tomasz Napierala 			    sense_len, csio->sense_len);
978009ea47eSEdward Tomasz Napierala 			sense_len = csio->sense_len;
979009ea47eSEdward Tomasz Napierala 		}
980009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(response, sizeof(sense_len), &csio->sense_data, sense_len);
981009ea47eSEdward Tomasz Napierala 		csio->sense_resid = csio->sense_len - sense_len;
98273e2e95dSAlexander Motin 		ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
983009ea47eSEdward Tomasz Napierala 	}
984009ea47eSEdward Tomasz Napierala 
985009ea47eSEdward Tomasz Napierala out:
986009ea47eSEdward Tomasz Napierala 	if (bhssr->bhssr_flags & BHSSR_FLAGS_RESIDUAL_UNDERFLOW)
987009ea47eSEdward Tomasz Napierala 		csio->resid = ntohl(bhssr->bhssr_residual_count);
988009ea47eSEdward Tomasz Napierala 
989009ea47eSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
99073e2e95dSAlexander Motin 		KASSERT(received <= csio->dxfer_len,
99173e2e95dSAlexander Motin 		    ("received > csio->dxfer_len"));
99273e2e95dSAlexander Motin 		if (received < csio->dxfer_len) {
99373e2e95dSAlexander Motin 			if (csio->resid != csio->dxfer_len - received) {
994009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_WARN(is, "underflow mismatch: "
995009ea47eSEdward Tomasz Napierala 				    "target indicates %d, we calculated %zd",
99673e2e95dSAlexander Motin 				    csio->resid, csio->dxfer_len - received);
997009ea47eSEdward Tomasz Napierala 			}
99873e2e95dSAlexander Motin 			csio->resid = csio->dxfer_len - received;
999009ea47eSEdward Tomasz Napierala 		}
1000009ea47eSEdward Tomasz Napierala 	}
1001009ea47eSEdward Tomasz Napierala 
100273e2e95dSAlexander Motin 	xpt_done(ccb);
1003009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1004009ea47eSEdward Tomasz Napierala }
1005009ea47eSEdward Tomasz Napierala 
1006009ea47eSEdward Tomasz Napierala static void
1007aa75114cSAlexander Motin iscsi_pdu_handle_task_response(struct icl_pdu *response)
1008aa75114cSAlexander Motin {
1009aa75114cSAlexander Motin 	struct iscsi_bhs_task_management_response *bhstmr;
1010aa75114cSAlexander Motin 	struct iscsi_outstanding *io, *aio;
1011aa75114cSAlexander Motin 	struct iscsi_session *is;
1012aa75114cSAlexander Motin 
1013aa75114cSAlexander Motin 	is = PDU_SESSION(response);
1014aa75114cSAlexander Motin 
1015aa75114cSAlexander Motin 	bhstmr = (struct iscsi_bhs_task_management_response *)response->ip_bhs;
1016aa75114cSAlexander Motin 	io = iscsi_outstanding_find(is, bhstmr->bhstmr_initiator_task_tag);
1017aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb != NULL) {
1018aa75114cSAlexander Motin 		ISCSI_SESSION_WARN(is, "bad itt 0x%x",
1019aa75114cSAlexander Motin 		    bhstmr->bhstmr_initiator_task_tag);
1020aa75114cSAlexander Motin 		icl_pdu_free(response);
1021aa75114cSAlexander Motin 		iscsi_session_reconnect(is);
1022aa75114cSAlexander Motin 		return;
1023aa75114cSAlexander Motin 	}
1024aa75114cSAlexander Motin 
1025aa75114cSAlexander Motin 	if (bhstmr->bhstmr_response != BHSTMR_RESPONSE_FUNCTION_COMPLETE) {
1026aa75114cSAlexander Motin 		ISCSI_SESSION_WARN(is, "task response 0x%x",
1027aa75114cSAlexander Motin 		    bhstmr->bhstmr_response);
1028aa75114cSAlexander Motin 	} else {
10293dd2a7a5SAlexander Motin 		aio = iscsi_outstanding_find(is, io->io_referenced_task_tag);
1030aa75114cSAlexander Motin 		if (aio != NULL && aio->io_ccb != NULL)
1031ad10496cSAndriy Gapon 			iscsi_session_terminate_task(is, aio, CAM_REQ_ABORTED);
1032aa75114cSAlexander Motin 	}
1033aa75114cSAlexander Motin 
1034aa75114cSAlexander Motin 	iscsi_outstanding_remove(is, io);
1035aa75114cSAlexander Motin 	icl_pdu_free(response);
1036aa75114cSAlexander Motin }
1037aa75114cSAlexander Motin 
1038aa75114cSAlexander Motin static void
1039009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_data_in(struct icl_pdu *response)
1040009ea47eSEdward Tomasz Napierala {
1041009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_data_in *bhsdi;
1042009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
1043009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
104473e2e95dSAlexander Motin 	union ccb *ccb;
1045009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
104673e2e95dSAlexander Motin 	size_t data_segment_len, received, oreceived;
1047009ea47eSEdward Tomasz Napierala 
1048009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1049009ea47eSEdward Tomasz Napierala 	bhsdi = (struct iscsi_bhs_data_in *)response->ip_bhs;
1050009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhsdi->bhsdi_initiator_task_tag);
1051aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
1052009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhsdi->bhsdi_initiator_task_tag);
1053009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1054009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1055c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1056009ea47eSEdward Tomasz Napierala 		return;
1057009ea47eSEdward Tomasz Napierala 	}
1058009ea47eSEdward Tomasz Napierala 
1059*4f0f5bf9SJohn Baldwin 	if (io->io_datasn != ntohl(bhsdi->bhsdi_datasn)) {
1060*4f0f5bf9SJohn Baldwin 		ISCSI_SESSION_WARN(is, "received Data-In PDU with "
1061*4f0f5bf9SJohn Baldwin 		    "DataSN %u, while expected %u; dropping connection",
1062*4f0f5bf9SJohn Baldwin 		    ntohl(bhsdi->bhsdi_datasn), io->io_datasn);
1063*4f0f5bf9SJohn Baldwin 		icl_pdu_free(response);
1064*4f0f5bf9SJohn Baldwin 		iscsi_session_reconnect(is);
1065*4f0f5bf9SJohn Baldwin 		ISCSI_SESSION_UNLOCK(is);
1066*4f0f5bf9SJohn Baldwin 		return;
1067*4f0f5bf9SJohn Baldwin 	}
1068*4f0f5bf9SJohn Baldwin 	io->io_datasn += response->ip_additional_pdus + 1;
1069*4f0f5bf9SJohn Baldwin 
1070009ea47eSEdward Tomasz Napierala 	data_segment_len = icl_pdu_data_segment_length(response);
1071009ea47eSEdward Tomasz Napierala 	if (data_segment_len == 0) {
1072009ea47eSEdward Tomasz Napierala 		/*
1073009ea47eSEdward Tomasz Napierala 		 * "The sending of 0 length data segments should be avoided,
1074009ea47eSEdward Tomasz Napierala 		 * but initiators and targets MUST be able to properly receive
1075009ea47eSEdward Tomasz Napierala 		 * 0 length data segments."
1076009ea47eSEdward Tomasz Napierala 		 */
1077c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1078009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1079009ea47eSEdward Tomasz Napierala 		return;
1080009ea47eSEdward Tomasz Napierala 	}
1081009ea47eSEdward Tomasz Napierala 
1082009ea47eSEdward Tomasz Napierala 	/*
1083009ea47eSEdward Tomasz Napierala 	 * We need to track this for security reasons - without it, malicious target
1084009ea47eSEdward Tomasz Napierala 	 * could respond to SCSI READ without sending Data-In PDUs, which would result
1085009ea47eSEdward Tomasz Napierala 	 * in read operation on the initiator side returning random kernel data.
1086009ea47eSEdward Tomasz Napierala 	 */
1087009ea47eSEdward Tomasz Napierala 	if (ntohl(bhsdi->bhsdi_buffer_offset) != io->io_received) {
1088009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "data out of order; expected offset %zd, got %zd",
1089009ea47eSEdward Tomasz Napierala 		    io->io_received, (size_t)ntohl(bhsdi->bhsdi_buffer_offset));
1090009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1091009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1092c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1093009ea47eSEdward Tomasz Napierala 		return;
1094009ea47eSEdward Tomasz Napierala 	}
1095009ea47eSEdward Tomasz Napierala 
109673e2e95dSAlexander Motin 	ccb = io->io_ccb;
109773e2e95dSAlexander Motin 	csio = &ccb->csio;
1098009ea47eSEdward Tomasz Napierala 
1099d43c9ec1SEdward Tomasz Napierala 	if (io->io_received + data_segment_len > csio->dxfer_len) {
1100009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "oversize data segment (%zd bytes "
1101d43c9ec1SEdward Tomasz Napierala 		    "at offset %zd, buffer is %d)",
1102d43c9ec1SEdward Tomasz Napierala 		    data_segment_len, io->io_received, csio->dxfer_len);
1103009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1104009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1105c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1106009ea47eSEdward Tomasz Napierala 		return;
1107009ea47eSEdward Tomasz Napierala 	}
1108009ea47eSEdward Tomasz Napierala 
110973e2e95dSAlexander Motin 	oreceived = io->io_received;
1110009ea47eSEdward Tomasz Napierala 	io->io_received += data_segment_len;
111173e2e95dSAlexander Motin 	received = io->io_received;
1112c215ad3aSAlexander Motin 	if ((bhsdi->bhsdi_flags & BHSDI_FLAGS_S) != 0)
1113c215ad3aSAlexander Motin 		iscsi_outstanding_remove(is, io);
1114c215ad3aSAlexander Motin 	ISCSI_SESSION_UNLOCK(is);
1115c215ad3aSAlexander Motin 
111673e2e95dSAlexander Motin 	icl_pdu_get_data(response, 0, csio->data_ptr + oreceived, data_segment_len);
1117009ea47eSEdward Tomasz Napierala 
1118009ea47eSEdward Tomasz Napierala 	/*
1119009ea47eSEdward Tomasz Napierala 	 * XXX: Check F.
1120009ea47eSEdward Tomasz Napierala 	 */
112169647b7bSEdward Tomasz Napierala 	if ((bhsdi->bhsdi_flags & BHSDI_FLAGS_S) == 0) {
112269647b7bSEdward Tomasz Napierala 		/*
112369647b7bSEdward Tomasz Napierala 		 * Nothing more to do.
112469647b7bSEdward Tomasz Napierala 		 */
112569647b7bSEdward Tomasz Napierala 		icl_pdu_free(response);
112669647b7bSEdward Tomasz Napierala 		return;
112769647b7bSEdward Tomasz Napierala 	}
112869647b7bSEdward Tomasz Napierala 
1129009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "got S flag; status 0x%x", bhsdi->bhsdi_status);
1130009ea47eSEdward Tomasz Napierala 	if (bhsdi->bhsdi_status == 0) {
113173e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
1132009ea47eSEdward Tomasz Napierala 	} else {
113373e2e95dSAlexander Motin 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
113473e2e95dSAlexander Motin 			xpt_freeze_devq(ccb->ccb_h.path, 1);
1135009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
1136009ea47eSEdward Tomasz Napierala 		}
113773e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | CAM_DEV_QFRZN;
1138009ea47eSEdward Tomasz Napierala 		csio->scsi_status = bhsdi->bhsdi_status;
1139009ea47eSEdward Tomasz Napierala 	}
114069647b7bSEdward Tomasz Napierala 
114169647b7bSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
114273e2e95dSAlexander Motin 		KASSERT(received <= csio->dxfer_len,
114373e2e95dSAlexander Motin 		    ("received > csio->dxfer_len"));
114473e2e95dSAlexander Motin 		if (received < csio->dxfer_len) {
114569647b7bSEdward Tomasz Napierala 			csio->resid = ntohl(bhsdi->bhsdi_residual_count);
114673e2e95dSAlexander Motin 			if (csio->resid != csio->dxfer_len - received) {
114769647b7bSEdward Tomasz Napierala 				ISCSI_SESSION_WARN(is, "underflow mismatch: "
114869647b7bSEdward Tomasz Napierala 				    "target indicates %d, we calculated %zd",
114973e2e95dSAlexander Motin 				    csio->resid, csio->dxfer_len - received);
115069647b7bSEdward Tomasz Napierala 			}
115173e2e95dSAlexander Motin 			csio->resid = csio->dxfer_len - received;
115269647b7bSEdward Tomasz Napierala 		}
1153009ea47eSEdward Tomasz Napierala 	}
1154009ea47eSEdward Tomasz Napierala 
115573e2e95dSAlexander Motin 	xpt_done(ccb);
1156009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1157009ea47eSEdward Tomasz Napierala }
1158009ea47eSEdward Tomasz Napierala 
1159009ea47eSEdward Tomasz Napierala static void
1160009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_logout_response(struct icl_pdu *response)
1161009ea47eSEdward Tomasz Napierala {
1162009ea47eSEdward Tomasz Napierala 
1163009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(PDU_SESSION(response), "logout response");
1164009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1165009ea47eSEdward Tomasz Napierala }
1166009ea47eSEdward Tomasz Napierala 
1167009ea47eSEdward Tomasz Napierala static void
1168009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_r2t(struct icl_pdu *response)
1169009ea47eSEdward Tomasz Napierala {
1170009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
1171009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1172009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_r2t *bhsr2t;
1173009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_data_out *bhsdo;
1174009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
1175009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
1176f0594f52SJohn Baldwin 	size_t off, len, max_send_data_segment_length, total_len;
1177009ea47eSEdward Tomasz Napierala 	int error;
11783dd2a7a5SAlexander Motin 	uint32_t datasn = 0;
1179009ea47eSEdward Tomasz Napierala 
1180009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1181009ea47eSEdward Tomasz Napierala 
1182009ea47eSEdward Tomasz Napierala 	bhsr2t = (struct iscsi_bhs_r2t *)response->ip_bhs;
1183009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhsr2t->bhsr2t_initiator_task_tag);
1184aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
1185009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x; reconnecting",
1186009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_initiator_task_tag);
1187009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1188009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1189009ea47eSEdward Tomasz Napierala 		return;
1190009ea47eSEdward Tomasz Napierala 	}
1191009ea47eSEdward Tomasz Napierala 
1192009ea47eSEdward Tomasz Napierala 	csio = &io->io_ccb->csio;
1193009ea47eSEdward Tomasz Napierala 
1194009ea47eSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_OUT) {
1195009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "received R2T for read command; reconnecting");
1196009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1197009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1198009ea47eSEdward Tomasz Napierala 		return;
1199009ea47eSEdward Tomasz Napierala 	}
1200009ea47eSEdward Tomasz Napierala 
1201009ea47eSEdward Tomasz Napierala 	/*
1202009ea47eSEdward Tomasz Napierala 	 * XXX: Verify R2TSN.
1203009ea47eSEdward Tomasz Napierala 	 */
1204009ea47eSEdward Tomasz Napierala 
1205009ea47eSEdward Tomasz Napierala 	off = ntohl(bhsr2t->bhsr2t_buffer_offset);
1206d43c9ec1SEdward Tomasz Napierala 	if (off > csio->dxfer_len) {
1207d43c9ec1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requested invalid offset "
1208d43c9ec1SEdward Tomasz Napierala 		    "%zd, buffer is is %d; reconnecting", off, csio->dxfer_len);
1209d43c9ec1SEdward Tomasz Napierala 		icl_pdu_free(response);
1210d43c9ec1SEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1211d43c9ec1SEdward Tomasz Napierala 		return;
1212d43c9ec1SEdward Tomasz Napierala 	}
1213d43c9ec1SEdward Tomasz Napierala 
1214009ea47eSEdward Tomasz Napierala 	total_len = ntohl(bhsr2t->bhsr2t_desired_data_transfer_length);
1215d43c9ec1SEdward Tomasz Napierala 	if (total_len == 0 || total_len > csio->dxfer_len) {
1216d43c9ec1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requested invalid length "
1217d43c9ec1SEdward Tomasz Napierala 		    "%zd, buffer is %d; reconnecting", total_len, csio->dxfer_len);
1218d43c9ec1SEdward Tomasz Napierala 		icl_pdu_free(response);
1219d43c9ec1SEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1220d43c9ec1SEdward Tomasz Napierala 		return;
1221d43c9ec1SEdward Tomasz Napierala 	}
1222009ea47eSEdward Tomasz Napierala 
1223009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "r2t; off %zd, len %zd", off, total_len);
1224009ea47eSEdward Tomasz Napierala 
1225f0594f52SJohn Baldwin 	if (is->is_conn->ic_hw_isomax != 0)
1226f0594f52SJohn Baldwin 		max_send_data_segment_length = is->is_conn->ic_hw_isomax;
1227f0594f52SJohn Baldwin 	else
1228f0594f52SJohn Baldwin 		max_send_data_segment_length =
1229f0594f52SJohn Baldwin 		    is->is_conn->ic_max_send_data_segment_length;
1230009ea47eSEdward Tomasz Napierala 	for (;;) {
1231009ea47eSEdward Tomasz Napierala 		len = total_len;
1232009ea47eSEdward Tomasz Napierala 
1233f0594f52SJohn Baldwin 		if (len > max_send_data_segment_length)
1234f0594f52SJohn Baldwin 			len = max_send_data_segment_length;
1235009ea47eSEdward Tomasz Napierala 
1236009ea47eSEdward Tomasz Napierala 		if (off + len > csio->dxfer_len) {
1237d43c9ec1SEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "target requested invalid "
1238d43c9ec1SEdward Tomasz Napierala 			    "length/offset %zd, buffer is %d; reconnecting",
1239009ea47eSEdward Tomasz Napierala 			    off + len, csio->dxfer_len);
1240009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
1241009ea47eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
1242009ea47eSEdward Tomasz Napierala 			return;
1243009ea47eSEdward Tomasz Napierala 		}
1244009ea47eSEdward Tomasz Napierala 
1245d2d52b00SEdward Tomasz Napierala 		request = icl_pdu_new(response->ip_conn, M_NOWAIT);
1246009ea47eSEdward Tomasz Napierala 		if (request == NULL) {
1247009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
1248009ea47eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
1249009ea47eSEdward Tomasz Napierala 			return;
1250009ea47eSEdward Tomasz Napierala 		}
1251009ea47eSEdward Tomasz Napierala 
1252009ea47eSEdward Tomasz Napierala 		bhsdo = (struct iscsi_bhs_data_out *)request->ip_bhs;
1253009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_opcode = ISCSI_BHS_OPCODE_SCSI_DATA_OUT;
1254009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_lun = bhsr2t->bhsr2t_lun;
1255009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_initiator_task_tag =
1256009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_initiator_task_tag;
1257009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_target_transfer_tag =
1258009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_target_transfer_tag;
1259f0594f52SJohn Baldwin 		bhsdo->bhsdo_datasn = htonl(datasn);
1260009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_buffer_offset = htonl(off);
1261d43c9ec1SEdward Tomasz Napierala 		error = icl_pdu_append_data(request, csio->data_ptr + off, len,
1262d43c9ec1SEdward Tomasz Napierala 		    M_NOWAIT);
1263009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1264d43c9ec1SEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
1265d43c9ec1SEdward Tomasz Napierala 			    "reconnecting");
1266009ea47eSEdward Tomasz Napierala 			icl_pdu_free(request);
1267009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
1268009ea47eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
1269009ea47eSEdward Tomasz Napierala 			return;
1270009ea47eSEdward Tomasz Napierala 		}
1271009ea47eSEdward Tomasz Napierala 
1272f0594f52SJohn Baldwin 		datasn += howmany(len,
1273f0594f52SJohn Baldwin 		    is->is_conn->ic_max_send_data_segment_length);
1274009ea47eSEdward Tomasz Napierala 		off += len;
1275009ea47eSEdward Tomasz Napierala 		total_len -= len;
1276009ea47eSEdward Tomasz Napierala 
1277009ea47eSEdward Tomasz Napierala 		if (total_len == 0) {
1278009ea47eSEdward Tomasz Napierala 			bhsdo->bhsdo_flags |= BHSDO_FLAGS_F;
1279009ea47eSEdward Tomasz Napierala 			//ISCSI_SESSION_DEBUG(is, "setting F, off %zd", off);
1280009ea47eSEdward Tomasz Napierala 		} else {
1281009ea47eSEdward Tomasz Napierala 			//ISCSI_SESSION_DEBUG(is, "not finished, off %zd", off);
1282009ea47eSEdward Tomasz Napierala 		}
1283009ea47eSEdward Tomasz Napierala 
1284009ea47eSEdward Tomasz Napierala 		iscsi_pdu_queue_locked(request);
1285009ea47eSEdward Tomasz Napierala 
1286009ea47eSEdward Tomasz Napierala 		if (total_len == 0)
1287009ea47eSEdward Tomasz Napierala 			break;
1288009ea47eSEdward Tomasz Napierala 	}
1289009ea47eSEdward Tomasz Napierala 
1290009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1291009ea47eSEdward Tomasz Napierala }
1292009ea47eSEdward Tomasz Napierala 
1293009ea47eSEdward Tomasz Napierala static void
1294009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_async_message(struct icl_pdu *response)
1295009ea47eSEdward Tomasz Napierala {
1296009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_asynchronous_message *bhsam;
1297009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1298009ea47eSEdward Tomasz Napierala 
1299009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1300009ea47eSEdward Tomasz Napierala 	bhsam = (struct iscsi_bhs_asynchronous_message *)response->ip_bhs;
1301009ea47eSEdward Tomasz Napierala 	switch (bhsam->bhsam_async_event) {
1302009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_REQUESTS_LOGOUT:
1303009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requests logout; removing session");
1304009ea47eSEdward Tomasz Napierala 		iscsi_session_logout(is);
1305009ea47eSEdward Tomasz Napierala 		iscsi_session_terminate(is);
1306009ea47eSEdward Tomasz Napierala 		break;
1307009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_TERMINATES_CONNECTION:
13086960c4e1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target indicates it will drop the connection");
1309009ea47eSEdward Tomasz Napierala 		break;
1310009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_TERMINATES_SESSION:
13116960c4e1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target indicates it will drop the session");
1312009ea47eSEdward Tomasz Napierala 		break;
1313009ea47eSEdward Tomasz Napierala 	default:
1314009ea47eSEdward Tomasz Napierala 		/*
1315009ea47eSEdward Tomasz Napierala 		 * XXX: Technically, we're obligated to also handle
1316009ea47eSEdward Tomasz Napierala 		 * 	parameter renegotiation.
1317009ea47eSEdward Tomasz Napierala 		 */
1318009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "ignoring AsyncEvent %d", bhsam->bhsam_async_event);
1319009ea47eSEdward Tomasz Napierala 		break;
1320009ea47eSEdward Tomasz Napierala 	}
1321009ea47eSEdward Tomasz Napierala 
1322009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1323009ea47eSEdward Tomasz Napierala }
1324009ea47eSEdward Tomasz Napierala 
1325009ea47eSEdward Tomasz Napierala static void
1326009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_reject(struct icl_pdu *response)
1327009ea47eSEdward Tomasz Napierala {
1328009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_reject *bhsr;
1329009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1330009ea47eSEdward Tomasz Napierala 
1331009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1332009ea47eSEdward Tomasz Napierala 	bhsr = (struct iscsi_bhs_reject *)response->ip_bhs;
1333009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_WARN(is, "received Reject PDU, reason 0x%x; protocol error?",
1334009ea47eSEdward Tomasz Napierala 	    bhsr->bhsr_reason);
1335009ea47eSEdward Tomasz Napierala 
1336009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1337009ea47eSEdward Tomasz Napierala }
1338009ea47eSEdward Tomasz Napierala 
1339009ea47eSEdward Tomasz Napierala static int
1340009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_wait(struct iscsi_softc *sc,
1341009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_request *request)
1342009ea47eSEdward Tomasz Napierala {
1343009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
134497b84d34SNavdeep Parhar 	struct icl_drv_limits idl;
1345009ea47eSEdward Tomasz Napierala 	int error;
1346009ea47eSEdward Tomasz Napierala 
1347009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1348009ea47eSEdward Tomasz Napierala 	for (;;) {
1349009ea47eSEdward Tomasz Napierala 		TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
13502be596adSEdward Tomasz Napierala 			ISCSI_SESSION_LOCK(is);
1351ba165a31SEdward Tomasz Napierala 			if (is->is_conf.isc_enable == 0 &&
1352ba165a31SEdward Tomasz Napierala 			    is->is_conf.isc_discovery == 0) {
1353ba165a31SEdward Tomasz Napierala 				ISCSI_SESSION_UNLOCK(is);
1354ba165a31SEdward Tomasz Napierala 				continue;
1355ba165a31SEdward Tomasz Napierala 			}
1356009ea47eSEdward Tomasz Napierala 			if (is->is_waiting_for_iscsid)
1357009ea47eSEdward Tomasz Napierala 				break;
13582be596adSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1359009ea47eSEdward Tomasz Napierala 		}
1360009ea47eSEdward Tomasz Napierala 
1361009ea47eSEdward Tomasz Napierala 		if (is == NULL) {
136289df4847SJohn Baldwin 			if (sc->sc_unloading) {
136389df4847SJohn Baldwin 				sx_sunlock(&sc->sc_lock);
136489df4847SJohn Baldwin 				return (ENXIO);
136589df4847SJohn Baldwin 			}
136689df4847SJohn Baldwin 
1367009ea47eSEdward Tomasz Napierala 			/*
1368009ea47eSEdward Tomasz Napierala 			 * No session requires attention from iscsid(8); wait.
1369009ea47eSEdward Tomasz Napierala 			 */
1370009ea47eSEdward Tomasz Napierala 			error = cv_wait_sig(&sc->sc_cv, &sc->sc_lock);
1371009ea47eSEdward Tomasz Napierala 			if (error != 0) {
1372009ea47eSEdward Tomasz Napierala 				sx_sunlock(&sc->sc_lock);
1373009ea47eSEdward Tomasz Napierala 				return (error);
1374009ea47eSEdward Tomasz Napierala 			}
1375009ea47eSEdward Tomasz Napierala 			continue;
1376009ea47eSEdward Tomasz Napierala 		}
1377009ea47eSEdward Tomasz Napierala 
1378009ea47eSEdward Tomasz Napierala 		is->is_waiting_for_iscsid = false;
1379009ea47eSEdward Tomasz Napierala 		is->is_login_phase = true;
1380009ea47eSEdward Tomasz Napierala 		is->is_reason[0] = '\0';
1381009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1382009ea47eSEdward Tomasz Napierala 
1383009ea47eSEdward Tomasz Napierala 		request->idr_session_id = is->is_id;
1384ffe82e05SAlexander Motin 		memcpy(&request->idr_isid, &is->is_isid,
1385ffe82e05SAlexander Motin 		    sizeof(request->idr_isid));
1386ffe82e05SAlexander Motin 		request->idr_tsih = 0;	/* New or reinstated session. */
1387009ea47eSEdward Tomasz Napierala 		memcpy(&request->idr_conf, &is->is_conf,
1388009ea47eSEdward Tomasz Napierala 		    sizeof(request->idr_conf));
1389009ea47eSEdward Tomasz Napierala 
139082babffbSEdward Tomasz Napierala 		error = icl_limits(is->is_conf.isc_offload,
139197b84d34SNavdeep Parhar 		    is->is_conf.isc_iser, &idl);
139282babffbSEdward Tomasz Napierala 		if (error != 0) {
139382babffbSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "icl_limits for offload \"%s\" "
139482babffbSEdward Tomasz Napierala 			    "failed with error %d", is->is_conf.isc_offload,
139582babffbSEdward Tomasz Napierala 			    error);
139682babffbSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
139782babffbSEdward Tomasz Napierala 			return (error);
139882babffbSEdward Tomasz Napierala 		}
139997b84d34SNavdeep Parhar 		request->idr_limits.isl_max_recv_data_segment_length =
140097b84d34SNavdeep Parhar 		    idl.idl_max_recv_data_segment_length;
140197b84d34SNavdeep Parhar 		request->idr_limits.isl_max_send_data_segment_length =
140248214203SNavdeep Parhar 		    idl.idl_max_send_data_segment_length;
140397b84d34SNavdeep Parhar 		request->idr_limits.isl_max_burst_length =
140497b84d34SNavdeep Parhar 		    idl.idl_max_burst_length;
140597b84d34SNavdeep Parhar 		request->idr_limits.isl_first_burst_length =
140697b84d34SNavdeep Parhar 		    idl.idl_first_burst_length;
140782babffbSEdward Tomasz Napierala 
1408009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1409009ea47eSEdward Tomasz Napierala 		return (0);
1410009ea47eSEdward Tomasz Napierala 	}
1411009ea47eSEdward Tomasz Napierala }
1412009ea47eSEdward Tomasz Napierala 
1413009ea47eSEdward Tomasz Napierala static int
1414009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_handoff(struct iscsi_softc *sc,
1415009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_handoff *handoff)
1416009ea47eSEdward Tomasz Napierala {
1417009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1418f5cadbc4SNavdeep Parhar 	struct icl_conn *ic;
1419009ea47eSEdward Tomasz Napierala 	int error;
1420009ea47eSEdward Tomasz Napierala 
1421009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1422009ea47eSEdward Tomasz Napierala 
1423009ea47eSEdward Tomasz Napierala 	/*
1424009ea47eSEdward Tomasz Napierala 	 * Find the session to hand off socket to.
1425009ea47eSEdward Tomasz Napierala 	 */
1426009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1427009ea47eSEdward Tomasz Napierala 		if (is->is_id == handoff->idh_session_id)
1428009ea47eSEdward Tomasz Napierala 			break;
1429009ea47eSEdward Tomasz Napierala 	}
1430009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1431009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1432009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1433009ea47eSEdward Tomasz Napierala 	}
1434009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1435f5cadbc4SNavdeep Parhar 	ic = is->is_conn;
1436009ea47eSEdward Tomasz Napierala 	if (is->is_conf.isc_discovery || is->is_terminating) {
1437009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1438009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1439009ea47eSEdward Tomasz Napierala 		return (EINVAL);
1440009ea47eSEdward Tomasz Napierala 	}
14410260023fSEdward Tomasz Napierala 	if (is->is_connected) {
14420260023fSEdward Tomasz Napierala 		/*
14430260023fSEdward Tomasz Napierala 		 * This might have happened because another iscsid(8)
14440260023fSEdward Tomasz Napierala 		 * instance handed off the connection in the meantime.
14450260023fSEdward Tomasz Napierala 		 * Just return.
14460260023fSEdward Tomasz Napierala 		 */
14470260023fSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "handoff on already connected "
14480260023fSEdward Tomasz Napierala 		    "session");
14490260023fSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
14500260023fSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
14510260023fSEdward Tomasz Napierala 		return (EBUSY);
14520260023fSEdward Tomasz Napierala 	}
1453009ea47eSEdward Tomasz Napierala 
1454009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_target_alias, handoff->idh_target_alias,
1455009ea47eSEdward Tomasz Napierala 	    sizeof(is->is_target_alias));
1456ffe82e05SAlexander Motin 	is->is_tsih = handoff->idh_tsih;
1457009ea47eSEdward Tomasz Napierala 	is->is_statsn = handoff->idh_statsn;
14587dbbd1aeSAlexander Motin 	is->is_protocol_level = handoff->idh_protocol_level;
1459009ea47eSEdward Tomasz Napierala 	is->is_initial_r2t = handoff->idh_initial_r2t;
1460009ea47eSEdward Tomasz Napierala 	is->is_immediate_data = handoff->idh_immediate_data;
1461c8b73c2cSNavdeep Parhar 
14620cc7d64aSJohn Baldwin 	ic->ic_max_recv_data_segment_length =
146397b84d34SNavdeep Parhar 	    handoff->idh_max_recv_data_segment_length;
14640cc7d64aSJohn Baldwin 	ic->ic_max_send_data_segment_length =
146597b84d34SNavdeep Parhar 	    handoff->idh_max_send_data_segment_length;
1466009ea47eSEdward Tomasz Napierala 	is->is_max_burst_length = handoff->idh_max_burst_length;
1467009ea47eSEdward Tomasz Napierala 	is->is_first_burst_length = handoff->idh_first_burst_length;
1468009ea47eSEdward Tomasz Napierala 
1469009ea47eSEdward Tomasz Napierala 	if (handoff->idh_header_digest == ISCSI_DIGEST_CRC32C)
1470f5cadbc4SNavdeep Parhar 		ic->ic_header_crc32c = true;
1471009ea47eSEdward Tomasz Napierala 	else
1472f5cadbc4SNavdeep Parhar 		ic->ic_header_crc32c = false;
1473009ea47eSEdward Tomasz Napierala 	if (handoff->idh_data_digest == ISCSI_DIGEST_CRC32C)
1474f5cadbc4SNavdeep Parhar 		ic->ic_data_crc32c = true;
1475009ea47eSEdward Tomasz Napierala 	else
1476f5cadbc4SNavdeep Parhar 		ic->ic_data_crc32c = false;
1477b218ca6fSEdward Tomasz Napierala 	ic->ic_maxtags = maxtags;
1478009ea47eSEdward Tomasz Napierala 
1479009ea47eSEdward Tomasz Napierala 	is->is_cmdsn = 0;
1480cf23c509SEdward Tomasz Napierala 	is->is_expcmdsn = 0;
1481cf23c509SEdward Tomasz Napierala 	is->is_maxcmdsn = 0;
1482009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = false;
1483009ea47eSEdward Tomasz Napierala 	is->is_login_phase = false;
1484009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
1485009ea47eSEdward Tomasz Napierala 	is->is_connected = true;
1486009ea47eSEdward Tomasz Napierala 	is->is_reason[0] = '\0';
1487009ea47eSEdward Tomasz Napierala 
1488009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1489009ea47eSEdward Tomasz Napierala 
149057a4f20bSEdward Tomasz Napierala 	/*
1491906a424bSEdward Tomasz Napierala 	 * If we're going through the proxy, the idh_socket will be 0,
1492906a424bSEdward Tomasz Napierala 	 * and the ICL module can simply ignore this call.  It can also
1493906a424bSEdward Tomasz Napierala 	 * use it to determine it's no longer in the Login phase.
149457a4f20bSEdward Tomasz Napierala 	 */
1495f5cadbc4SNavdeep Parhar 	error = icl_conn_handoff(ic, handoff->idh_socket);
1496009ea47eSEdward Tomasz Napierala 	if (error != 0) {
1497009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1498009ea47eSEdward Tomasz Napierala 		iscsi_session_terminate(is);
1499009ea47eSEdward Tomasz Napierala 		return (error);
1500009ea47eSEdward Tomasz Napierala 	}
1501009ea47eSEdward Tomasz Napierala 
1502009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1503009ea47eSEdward Tomasz Napierala 
1504009ea47eSEdward Tomasz Napierala 	if (is->is_sim != NULL) {
1505009ea47eSEdward Tomasz Napierala 		/*
1506009ea47eSEdward Tomasz Napierala 		 * When reconnecting, there already is SIM allocated for the session.
1507009ea47eSEdward Tomasz Napierala 		 */
1508009ea47eSEdward Tomasz Napierala 		KASSERT(is->is_simq_frozen, ("reconnect without frozen simq"));
1509009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1510009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "releasing");
1511009ea47eSEdward Tomasz Napierala 		is->is_simq_frozen = false;
1512186bcdaaSEdward Tomasz Napierala 		xpt_release_simq(is->is_sim, 1);
1513009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1514009ea47eSEdward Tomasz Napierala 
1515009ea47eSEdward Tomasz Napierala 	} else {
1516009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1517b218ca6fSEdward Tomasz Napierala 		is->is_devq = cam_simq_alloc(ic->ic_maxtags);
1518009ea47eSEdward Tomasz Napierala 		if (is->is_devq == NULL) {
1519009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate simq");
1520009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1521009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1522009ea47eSEdward Tomasz Napierala 		}
1523009ea47eSEdward Tomasz Napierala 
152447769bc5SJohn Baldwin 		is->is_sim = cam_sim_alloc(iscsi_action, NULL, "iscsi",
1525009ea47eSEdward Tomasz Napierala 		    is, is->is_id /* unit */, &is->is_lock,
1526b218ca6fSEdward Tomasz Napierala 		    1, ic->ic_maxtags, is->is_devq);
1527009ea47eSEdward Tomasz Napierala 		if (is->is_sim == NULL) {
1528009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1529009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate SIM");
1530009ea47eSEdward Tomasz Napierala 			cam_simq_free(is->is_devq);
1531009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1532009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1533009ea47eSEdward Tomasz Napierala 		}
1534009ea47eSEdward Tomasz Napierala 
153530f8afd0SWarner Losh 		if (xpt_bus_register(is->is_sim, NULL, 0) != 0) {
1536009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1537009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to register bus");
1538009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1539009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1540009ea47eSEdward Tomasz Napierala 		}
1541009ea47eSEdward Tomasz Napierala 
1542009ea47eSEdward Tomasz Napierala 		error = xpt_create_path(&is->is_path, /*periph*/NULL,
1543009ea47eSEdward Tomasz Napierala 		    cam_sim_path(is->is_sim), CAM_TARGET_WILDCARD,
1544009ea47eSEdward Tomasz Napierala 		    CAM_LUN_WILDCARD);
1545009ea47eSEdward Tomasz Napierala 		if (error != CAM_REQ_CMP) {
1546009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1547009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to create path");
1548009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1549009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1550009ea47eSEdward Tomasz Napierala 		}
1551009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1552009ea47eSEdward Tomasz Napierala 	}
1553009ea47eSEdward Tomasz Napierala 
1554009ea47eSEdward Tomasz Napierala 	return (0);
1555009ea47eSEdward Tomasz Napierala }
1556009ea47eSEdward Tomasz Napierala 
1557009ea47eSEdward Tomasz Napierala static int
1558009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_fail(struct iscsi_softc *sc,
1559009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_fail *fail)
1560009ea47eSEdward Tomasz Napierala {
1561009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1562009ea47eSEdward Tomasz Napierala 
1563009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1564009ea47eSEdward Tomasz Napierala 
1565009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1566009ea47eSEdward Tomasz Napierala 		if (is->is_id == fail->idf_session_id)
1567009ea47eSEdward Tomasz Napierala 			break;
1568009ea47eSEdward Tomasz Napierala 	}
1569009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1570009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1571009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1572009ea47eSEdward Tomasz Napierala 	}
1573009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1574009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "iscsid(8) failed: %s",
1575009ea47eSEdward Tomasz Napierala 	    fail->idf_reason);
1576009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, fail->idf_reason, sizeof(is->is_reason));
1577009ea47eSEdward Tomasz Napierala 	//is->is_waiting_for_iscsid = false;
1578009ea47eSEdward Tomasz Napierala 	//is->is_login_phase = true;
1579009ea47eSEdward Tomasz Napierala 	//iscsi_session_reconnect(is);
1580009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1581009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1582009ea47eSEdward Tomasz Napierala 
1583009ea47eSEdward Tomasz Napierala 	return (0);
1584009ea47eSEdward Tomasz Napierala }
1585009ea47eSEdward Tomasz Napierala 
1586009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
1587009ea47eSEdward Tomasz Napierala static int
1588009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_connect(struct iscsi_softc *sc,
1589009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_connect *idc)
1590009ea47eSEdward Tomasz Napierala {
1591009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1592009ea47eSEdward Tomasz Napierala 	struct sockaddr *from_sa, *to_sa;
1593009ea47eSEdward Tomasz Napierala 	int error;
1594009ea47eSEdward Tomasz Napierala 
1595009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1596009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1597009ea47eSEdward Tomasz Napierala 		if (is->is_id == idc->idc_session_id)
1598009ea47eSEdward Tomasz Napierala 			break;
1599009ea47eSEdward Tomasz Napierala 	}
1600009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1601009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1602009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1603009ea47eSEdward Tomasz Napierala 	}
1604009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1605009ea47eSEdward Tomasz Napierala 
1606009ea47eSEdward Tomasz Napierala 	if (idc->idc_from_addrlen > 0) {
1607009ea47eSEdward Tomasz Napierala 		error = getsockaddr(&from_sa, (void *)idc->idc_from_addr, idc->idc_from_addrlen);
160857a4f20bSEdward Tomasz Napierala 		if (error != 0) {
160957a4f20bSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is,
161057a4f20bSEdward Tomasz Napierala 			    "getsockaddr failed with error %d", error);
1611009ea47eSEdward Tomasz Napierala 			return (error);
161257a4f20bSEdward Tomasz Napierala 		}
1613009ea47eSEdward Tomasz Napierala 	} else {
1614009ea47eSEdward Tomasz Napierala 		from_sa = NULL;
1615009ea47eSEdward Tomasz Napierala 	}
1616009ea47eSEdward Tomasz Napierala 	error = getsockaddr(&to_sa, (void *)idc->idc_to_addr, idc->idc_to_addrlen);
1617009ea47eSEdward Tomasz Napierala 	if (error != 0) {
161857a4f20bSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "getsockaddr failed with error %d",
161957a4f20bSEdward Tomasz Napierala 		    error);
1620009ea47eSEdward Tomasz Napierala 		free(from_sa, M_SONAME);
1621009ea47eSEdward Tomasz Napierala 		return (error);
1622009ea47eSEdward Tomasz Napierala 	}
1623009ea47eSEdward Tomasz Napierala 
1624009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1625a3fd63f2SEdward Tomasz Napierala 	is->is_statsn = 0;
1626a3fd63f2SEdward Tomasz Napierala 	is->is_cmdsn = 0;
1627a3fd63f2SEdward Tomasz Napierala 	is->is_expcmdsn = 0;
1628a3fd63f2SEdward Tomasz Napierala 	is->is_maxcmdsn = 0;
1629009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = false;
1630009ea47eSEdward Tomasz Napierala 	is->is_login_phase = true;
1631009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
1632009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1633009ea47eSEdward Tomasz Napierala 
1634f41492b0SEdward Tomasz Napierala 	error = icl_conn_connect(is->is_conn, idc->idc_domain,
1635009ea47eSEdward Tomasz Napierala 	    idc->idc_socktype, idc->idc_protocol, from_sa, to_sa);
1636009ea47eSEdward Tomasz Napierala 	free(from_sa, M_SONAME);
1637009ea47eSEdward Tomasz Napierala 	free(to_sa, M_SONAME);
1638009ea47eSEdward Tomasz Napierala 
1639009ea47eSEdward Tomasz Napierala 	/*
1640009ea47eSEdward Tomasz Napierala 	 * Digests are always disabled during login phase.
1641009ea47eSEdward Tomasz Napierala 	 */
1642009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_header_crc32c = false;
1643009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_data_crc32c = false;
1644009ea47eSEdward Tomasz Napierala 
1645009ea47eSEdward Tomasz Napierala 	return (error);
1646009ea47eSEdward Tomasz Napierala }
1647009ea47eSEdward Tomasz Napierala 
1648009ea47eSEdward Tomasz Napierala static int
1649009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_send(struct iscsi_softc *sc,
1650009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_send *ids)
1651009ea47eSEdward Tomasz Napierala {
1652009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1653009ea47eSEdward Tomasz Napierala 	struct icl_pdu *ip;
1654009ea47eSEdward Tomasz Napierala 	size_t datalen;
1655009ea47eSEdward Tomasz Napierala 	void *data;
1656009ea47eSEdward Tomasz Napierala 	int error;
1657009ea47eSEdward Tomasz Napierala 
1658009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1659009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1660009ea47eSEdward Tomasz Napierala 		if (is->is_id == ids->ids_session_id)
1661009ea47eSEdward Tomasz Napierala 			break;
1662009ea47eSEdward Tomasz Napierala 	}
1663009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1664009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1665009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1666009ea47eSEdward Tomasz Napierala 	}
1667009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1668009ea47eSEdward Tomasz Napierala 
1669009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase == false)
1670009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1671009ea47eSEdward Tomasz Napierala 
1672009ea47eSEdward Tomasz Napierala 	if (is->is_terminating || is->is_reconnecting)
1673009ea47eSEdward Tomasz Napierala 		return (EIO);
1674009ea47eSEdward Tomasz Napierala 
1675009ea47eSEdward Tomasz Napierala 	datalen = ids->ids_data_segment_len;
16760cc7d64aSJohn Baldwin 	if (datalen > is->is_conn->ic_max_send_data_segment_length)
1677009ea47eSEdward Tomasz Napierala 		return (EINVAL);
1678009ea47eSEdward Tomasz Napierala 	if (datalen > 0) {
1679009ea47eSEdward Tomasz Napierala 		data = malloc(datalen, M_ISCSI, M_WAITOK);
1680009ea47eSEdward Tomasz Napierala 		error = copyin(ids->ids_data_segment, data, datalen);
1681009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1682009ea47eSEdward Tomasz Napierala 			free(data, M_ISCSI);
1683009ea47eSEdward Tomasz Napierala 			return (error);
1684009ea47eSEdward Tomasz Napierala 		}
1685009ea47eSEdward Tomasz Napierala 	}
1686009ea47eSEdward Tomasz Napierala 
1687d2d52b00SEdward Tomasz Napierala 	ip = icl_pdu_new(is->is_conn, M_WAITOK);
1688009ea47eSEdward Tomasz Napierala 	memcpy(ip->ip_bhs, ids->ids_bhs, sizeof(*ip->ip_bhs));
1689009ea47eSEdward Tomasz Napierala 	if (datalen > 0) {
1690009ea47eSEdward Tomasz Napierala 		error = icl_pdu_append_data(ip, data, datalen, M_WAITOK);
1691009ea47eSEdward Tomasz Napierala 		KASSERT(error == 0, ("icl_pdu_append_data(..., M_WAITOK) failed"));
1692009ea47eSEdward Tomasz Napierala 		free(data, M_ISCSI);
1693009ea47eSEdward Tomasz Napierala 	}
1694d66a906bSEdward Tomasz Napierala 	iscsi_pdu_queue(ip);
1695009ea47eSEdward Tomasz Napierala 
1696009ea47eSEdward Tomasz Napierala 	return (0);
1697009ea47eSEdward Tomasz Napierala }
1698009ea47eSEdward Tomasz Napierala 
1699009ea47eSEdward Tomasz Napierala static int
1700009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_receive(struct iscsi_softc *sc,
1701009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_receive *idr)
1702009ea47eSEdward Tomasz Napierala {
1703009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1704009ea47eSEdward Tomasz Napierala 	struct icl_pdu *ip;
1705009ea47eSEdward Tomasz Napierala 	void *data;
17062f0586b2SEdward Tomasz Napierala 	int error;
1707009ea47eSEdward Tomasz Napierala 
1708009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1709009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1710009ea47eSEdward Tomasz Napierala 		if (is->is_id == idr->idr_session_id)
1711009ea47eSEdward Tomasz Napierala 			break;
1712009ea47eSEdward Tomasz Napierala 	}
1713009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1714009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1715009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1716009ea47eSEdward Tomasz Napierala 	}
1717009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1718009ea47eSEdward Tomasz Napierala 
1719009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase == false)
1720009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1721009ea47eSEdward Tomasz Napierala 
1722009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1723009ea47eSEdward Tomasz Napierala 	while (is->is_login_pdu == NULL &&
1724009ea47eSEdward Tomasz Napierala 	    is->is_terminating == false &&
17252f0586b2SEdward Tomasz Napierala 	    is->is_reconnecting == false) {
17262f0586b2SEdward Tomasz Napierala 		error = cv_wait_sig(&is->is_login_cv, &is->is_lock);
17272f0586b2SEdward Tomasz Napierala 		if (error != 0) {
17282f0586b2SEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
17292f0586b2SEdward Tomasz Napierala 			return (error);
17302f0586b2SEdward Tomasz Napierala 		}
17312f0586b2SEdward Tomasz Napierala 	}
1732009ea47eSEdward Tomasz Napierala 	if (is->is_terminating || is->is_reconnecting) {
1733009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1734009ea47eSEdward Tomasz Napierala 		return (EIO);
1735009ea47eSEdward Tomasz Napierala 	}
1736009ea47eSEdward Tomasz Napierala 	ip = is->is_login_pdu;
1737009ea47eSEdward Tomasz Napierala 	is->is_login_pdu = NULL;
1738009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1739009ea47eSEdward Tomasz Napierala 
1740009ea47eSEdward Tomasz Napierala 	if (ip->ip_data_len > idr->idr_data_segment_len) {
1741009ea47eSEdward Tomasz Napierala 		icl_pdu_free(ip);
1742009ea47eSEdward Tomasz Napierala 		return (EMSGSIZE);
1743009ea47eSEdward Tomasz Napierala 	}
1744009ea47eSEdward Tomasz Napierala 
1745009ea47eSEdward Tomasz Napierala 	copyout(ip->ip_bhs, idr->idr_bhs, sizeof(*ip->ip_bhs));
1746009ea47eSEdward Tomasz Napierala 	if (ip->ip_data_len > 0) {
1747009ea47eSEdward Tomasz Napierala 		data = malloc(ip->ip_data_len, M_ISCSI, M_WAITOK);
1748009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(ip, 0, data, ip->ip_data_len);
1749009ea47eSEdward Tomasz Napierala 		copyout(data, idr->idr_data_segment, ip->ip_data_len);
1750009ea47eSEdward Tomasz Napierala 		free(data, M_ISCSI);
1751009ea47eSEdward Tomasz Napierala 	}
1752009ea47eSEdward Tomasz Napierala 
1753009ea47eSEdward Tomasz Napierala 	icl_pdu_free(ip);
1754009ea47eSEdward Tomasz Napierala 
1755009ea47eSEdward Tomasz Napierala 	return (0);
1756009ea47eSEdward Tomasz Napierala }
1757009ea47eSEdward Tomasz Napierala #endif /* ICL_KERNEL_PROXY */
1758009ea47eSEdward Tomasz Napierala 
1759009ea47eSEdward Tomasz Napierala static void
1760009ea47eSEdward Tomasz Napierala iscsi_sanitize_session_conf(struct iscsi_session_conf *isc)
1761009ea47eSEdward Tomasz Napierala {
1762009ea47eSEdward Tomasz Napierala 	/*
1763009ea47eSEdward Tomasz Napierala 	 * Just make sure all the fields are null-terminated.
1764009ea47eSEdward Tomasz Napierala 	 *
1765009ea47eSEdward Tomasz Napierala 	 * XXX: This is not particularly secure.  We should
1766009ea47eSEdward Tomasz Napierala 	 * 	create our own conf and then copy in relevant
1767009ea47eSEdward Tomasz Napierala 	 * 	fields.
1768009ea47eSEdward Tomasz Napierala 	 */
1769009ea47eSEdward Tomasz Napierala 	isc->isc_initiator[ISCSI_NAME_LEN - 1] = '\0';
1770009ea47eSEdward Tomasz Napierala 	isc->isc_initiator_addr[ISCSI_ADDR_LEN - 1] = '\0';
1771009ea47eSEdward Tomasz Napierala 	isc->isc_initiator_alias[ISCSI_ALIAS_LEN - 1] = '\0';
1772009ea47eSEdward Tomasz Napierala 	isc->isc_target[ISCSI_NAME_LEN - 1] = '\0';
1773009ea47eSEdward Tomasz Napierala 	isc->isc_target_addr[ISCSI_ADDR_LEN - 1] = '\0';
1774009ea47eSEdward Tomasz Napierala 	isc->isc_user[ISCSI_NAME_LEN - 1] = '\0';
1775009ea47eSEdward Tomasz Napierala 	isc->isc_secret[ISCSI_SECRET_LEN - 1] = '\0';
1776009ea47eSEdward Tomasz Napierala 	isc->isc_mutual_user[ISCSI_NAME_LEN - 1] = '\0';
1777009ea47eSEdward Tomasz Napierala 	isc->isc_mutual_secret[ISCSI_SECRET_LEN - 1] = '\0';
1778009ea47eSEdward Tomasz Napierala }
1779009ea47eSEdward Tomasz Napierala 
178051be90b5SEdward Tomasz Napierala static bool
178151be90b5SEdward Tomasz Napierala iscsi_valid_session_conf(const struct iscsi_session_conf *isc)
178251be90b5SEdward Tomasz Napierala {
178351be90b5SEdward Tomasz Napierala 
178451be90b5SEdward Tomasz Napierala 	if (isc->isc_initiator[0] == '\0') {
178551be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_initiator");
178651be90b5SEdward Tomasz Napierala 		return (false);
178751be90b5SEdward Tomasz Napierala 	}
178851be90b5SEdward Tomasz Napierala 
178951be90b5SEdward Tomasz Napierala 	if (isc->isc_target_addr[0] == '\0') {
179051be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_target_addr");
179151be90b5SEdward Tomasz Napierala 		return (false);
179251be90b5SEdward Tomasz Napierala 	}
179351be90b5SEdward Tomasz Napierala 
179451be90b5SEdward Tomasz Napierala 	if (isc->isc_discovery != 0 && isc->isc_target[0] != 0) {
179551be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("non-empty isc_target for discovery session");
179651be90b5SEdward Tomasz Napierala 		return (false);
179751be90b5SEdward Tomasz Napierala 	}
179851be90b5SEdward Tomasz Napierala 
179951be90b5SEdward Tomasz Napierala 	if (isc->isc_discovery == 0 && isc->isc_target[0] == 0) {
180051be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_target for non-discovery session");
180151be90b5SEdward Tomasz Napierala 		return (false);
180251be90b5SEdward Tomasz Napierala 	}
180351be90b5SEdward Tomasz Napierala 
180451be90b5SEdward Tomasz Napierala 	return (true);
180551be90b5SEdward Tomasz Napierala }
180651be90b5SEdward Tomasz Napierala 
1807009ea47eSEdward Tomasz Napierala static int
1808009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_add(struct iscsi_softc *sc, struct iscsi_session_add *isa)
1809009ea47eSEdward Tomasz Napierala {
1810009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1811009ea47eSEdward Tomasz Napierala 	const struct iscsi_session *is2;
1812009ea47eSEdward Tomasz Napierala 	int error;
1813009ea47eSEdward Tomasz Napierala 
1814009ea47eSEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&isa->isa_conf);
181551be90b5SEdward Tomasz Napierala 	if (iscsi_valid_session_conf(&isa->isa_conf) == false)
181651be90b5SEdward Tomasz Napierala 		return (EINVAL);
1817009ea47eSEdward Tomasz Napierala 
1818009ea47eSEdward Tomasz Napierala 	is = malloc(sizeof(*is), M_ISCSI, M_ZERO | M_WAITOK);
1819009ea47eSEdward Tomasz Napierala 	memcpy(&is->is_conf, &isa->isa_conf, sizeof(is->is_conf));
1820009ea47eSEdward Tomasz Napierala 
1821009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
1822009ea47eSEdward Tomasz Napierala 
1823009ea47eSEdward Tomasz Napierala 	/*
1824009ea47eSEdward Tomasz Napierala 	 * Prevent duplicates.
1825009ea47eSEdward Tomasz Napierala 	 */
1826009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is2, &sc->sc_sessions, is_next) {
18277843bd03SEdward Tomasz Napierala 		if (!!is->is_conf.isc_discovery !=
18287843bd03SEdward Tomasz Napierala 		    !!is2->is_conf.isc_discovery)
18297843bd03SEdward Tomasz Napierala 			continue;
18307843bd03SEdward Tomasz Napierala 
18317843bd03SEdward Tomasz Napierala 		if (strcmp(is->is_conf.isc_target_addr,
18327843bd03SEdward Tomasz Napierala 		    is2->is_conf.isc_target_addr) != 0)
18337843bd03SEdward Tomasz Napierala 			continue;
18347843bd03SEdward Tomasz Napierala 
18357843bd03SEdward Tomasz Napierala 		if (is->is_conf.isc_discovery == 0 &&
18367843bd03SEdward Tomasz Napierala 		    strcmp(is->is_conf.isc_target,
18377843bd03SEdward Tomasz Napierala 		    is2->is_conf.isc_target) != 0)
18387843bd03SEdward Tomasz Napierala 			continue;
18397843bd03SEdward Tomasz Napierala 
1840009ea47eSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
18417843bd03SEdward Tomasz Napierala 		free(is, M_ISCSI);
1842009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1843009ea47eSEdward Tomasz Napierala 	}
1844009ea47eSEdward Tomasz Napierala 
184582babffbSEdward Tomasz Napierala 	is->is_conn = icl_new_conn(is->is_conf.isc_offload,
1846b8911594SEdward Tomasz Napierala 	    is->is_conf.isc_iser, "iscsi", &is->is_lock);
184782babffbSEdward Tomasz Napierala 	if (is->is_conn == NULL) {
184882babffbSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
184982babffbSEdward Tomasz Napierala 		free(is, M_ISCSI);
185082babffbSEdward Tomasz Napierala 		return (EINVAL);
185182babffbSEdward Tomasz Napierala 	}
1852009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_receive = iscsi_receive_callback;
1853009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_error = iscsi_error_callback;
1854009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_prv0 = is;
1855009ea47eSEdward Tomasz Napierala 	TAILQ_INIT(&is->is_outstanding);
185616c158a5SEdward Tomasz Napierala 	STAILQ_INIT(&is->is_postponed);
1857009ea47eSEdward Tomasz Napierala 	mtx_init(&is->is_lock, "iscsi_lock", NULL, MTX_DEF);
1858009ea47eSEdward Tomasz Napierala 	cv_init(&is->is_maintenance_cv, "iscsi_mt");
1859009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
1860009ea47eSEdward Tomasz Napierala 	cv_init(&is->is_login_cv, "iscsi_login");
1861009ea47eSEdward Tomasz Napierala #endif
1862009ea47eSEdward Tomasz Napierala 
18630cc7d64aSJohn Baldwin 	/*
18640cc7d64aSJohn Baldwin 	 * Set some default values, from RFC 3720, section 12.
18650cc7d64aSJohn Baldwin 	 *
18660cc7d64aSJohn Baldwin 	 * These values are updated by the handoff IOCTL, but are
18670cc7d64aSJohn Baldwin 	 * needed prior to the handoff to support sending the ISER
18680cc7d64aSJohn Baldwin 	 * login PDU.
18690cc7d64aSJohn Baldwin 	 */
18700cc7d64aSJohn Baldwin 	is->is_conn->ic_max_recv_data_segment_length = 8192;
18710cc7d64aSJohn Baldwin 	is->is_conn->ic_max_send_data_segment_length = 8192;
18720cc7d64aSJohn Baldwin 	is->is_max_burst_length = 262144;
18730cc7d64aSJohn Baldwin 	is->is_first_burst_length = 65536;
18740cc7d64aSJohn Baldwin 
1875009ea47eSEdward Tomasz Napierala 	is->is_softc = sc;
1876009ea47eSEdward Tomasz Napierala 	sc->sc_last_session_id++;
1877009ea47eSEdward Tomasz Napierala 	is->is_id = sc->sc_last_session_id;
1878ffe82e05SAlexander Motin 	is->is_isid[0] = 0x80; /* RFC 3720, 10.12.5: 10b, "Random" ISID. */
1879ffe82e05SAlexander Motin 	arc4rand(&is->is_isid[1], 5, 0);
1880ffe82e05SAlexander Motin 	is->is_tsih = 0;
1881009ea47eSEdward Tomasz Napierala 	callout_init(&is->is_callout, 1);
1882009ea47eSEdward Tomasz Napierala 
1883009ea47eSEdward Tomasz Napierala 	error = kthread_add(iscsi_maintenance_thread, is, NULL, NULL, 0, 0, "iscsimt");
1884009ea47eSEdward Tomasz Napierala 	if (error != 0) {
1885009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "kthread_add(9) failed with error %d", error);
188609f2b94bSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
1887009ea47eSEdward Tomasz Napierala 		return (error);
1888009ea47eSEdward Tomasz Napierala 	}
1889009ea47eSEdward Tomasz Napierala 
189009f2b94bSEdward Tomasz Napierala 	callout_reset(&is->is_callout, 1 * hz, iscsi_callout, is);
189109f2b94bSEdward Tomasz Napierala 	TAILQ_INSERT_TAIL(&sc->sc_sessions, is, is_next);
189209f2b94bSEdward Tomasz Napierala 
18932be596adSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1894ba165a31SEdward Tomasz Napierala 	/*
1895ba165a31SEdward Tomasz Napierala 	 * Don't notify iscsid(8) if the session is disabled and it's not
1896ba165a31SEdward Tomasz Napierala 	 * a discovery session,
1897ba165a31SEdward Tomasz Napierala 	 */
1898ba165a31SEdward Tomasz Napierala 	if (is->is_conf.isc_enable == 0 && is->is_conf.isc_discovery == 0) {
1899ba165a31SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1900ba165a31SEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
1901ba165a31SEdward Tomasz Napierala 		return (0);
1902ba165a31SEdward Tomasz Napierala 	}
1903ba165a31SEdward Tomasz Napierala 
1904009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = true;
1905009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
19062be596adSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1907009ea47eSEdward Tomasz Napierala 	cv_signal(&sc->sc_cv);
1908009ea47eSEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
1909009ea47eSEdward Tomasz Napierala 	return (0);
1910009ea47eSEdward Tomasz Napierala }
1911009ea47eSEdward Tomasz Napierala 
1912009ea47eSEdward Tomasz Napierala static bool
1913009ea47eSEdward Tomasz Napierala iscsi_session_conf_matches(unsigned int id1, const struct iscsi_session_conf *c1,
1914009ea47eSEdward Tomasz Napierala     unsigned int id2, const struct iscsi_session_conf *c2)
1915009ea47eSEdward Tomasz Napierala {
19166cc1e267SEdward Tomasz Napierala 
19176cc1e267SEdward Tomasz Napierala 	if (id2 != 0 && id2 != id1)
1918009ea47eSEdward Tomasz Napierala 		return (false);
19196cc1e267SEdward Tomasz Napierala 	if (c2->isc_target[0] != '\0' &&
19206cc1e267SEdward Tomasz Napierala 	    strcmp(c1->isc_target, c2->isc_target) != 0)
19216cc1e267SEdward Tomasz Napierala 		return (false);
19226cc1e267SEdward Tomasz Napierala 	if (c2->isc_target_addr[0] != '\0' &&
19236cc1e267SEdward Tomasz Napierala 	    strcmp(c1->isc_target_addr, c2->isc_target_addr) != 0)
19246cc1e267SEdward Tomasz Napierala 		return (false);
19256cc1e267SEdward Tomasz Napierala 	return (true);
1926009ea47eSEdward Tomasz Napierala }
1927009ea47eSEdward Tomasz Napierala 
1928009ea47eSEdward Tomasz Napierala static int
1929009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_remove(struct iscsi_softc *sc,
1930009ea47eSEdward Tomasz Napierala     struct iscsi_session_remove *isr)
1931009ea47eSEdward Tomasz Napierala {
1932009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is, *tmp;
1933009ea47eSEdward Tomasz Napierala 	bool found = false;
1934009ea47eSEdward Tomasz Napierala 
1935009ea47eSEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&isr->isr_conf);
1936009ea47eSEdward Tomasz Napierala 
1937009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
1938009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH_SAFE(is, &sc->sc_sessions, is_next, tmp) {
1939009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1940009ea47eSEdward Tomasz Napierala 		if (iscsi_session_conf_matches(is->is_id, &is->is_conf,
1941009ea47eSEdward Tomasz Napierala 		    isr->isr_session_id, &isr->isr_conf)) {
1942009ea47eSEdward Tomasz Napierala 			found = true;
1943009ea47eSEdward Tomasz Napierala 			iscsi_session_logout(is);
1944009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1945009ea47eSEdward Tomasz Napierala 		}
1946009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1947009ea47eSEdward Tomasz Napierala 	}
1948009ea47eSEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
1949009ea47eSEdward Tomasz Napierala 
1950009ea47eSEdward Tomasz Napierala 	if (!found)
1951009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1952009ea47eSEdward Tomasz Napierala 
1953009ea47eSEdward Tomasz Napierala 	return (0);
1954009ea47eSEdward Tomasz Napierala }
1955009ea47eSEdward Tomasz Napierala 
1956009ea47eSEdward Tomasz Napierala static int
1957009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_list(struct iscsi_softc *sc, struct iscsi_session_list *isl)
1958009ea47eSEdward Tomasz Napierala {
1959009ea47eSEdward Tomasz Napierala 	int error;
1960009ea47eSEdward Tomasz Napierala 	unsigned int i = 0;
1961009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1962009ea47eSEdward Tomasz Napierala 	struct iscsi_session_state iss;
1963009ea47eSEdward Tomasz Napierala 
1964009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1965009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1966009ea47eSEdward Tomasz Napierala 		if (i >= isl->isl_nentries) {
1967009ea47eSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
1968009ea47eSEdward Tomasz Napierala 			return (EMSGSIZE);
1969009ea47eSEdward Tomasz Napierala 		}
1970009ea47eSEdward Tomasz Napierala 		memset(&iss, 0, sizeof(iss));
1971009ea47eSEdward Tomasz Napierala 		memcpy(&iss.iss_conf, &is->is_conf, sizeof(iss.iss_conf));
1972009ea47eSEdward Tomasz Napierala 		iss.iss_id = is->is_id;
1973009ea47eSEdward Tomasz Napierala 		strlcpy(iss.iss_target_alias, is->is_target_alias, sizeof(iss.iss_target_alias));
1974009ea47eSEdward Tomasz Napierala 		strlcpy(iss.iss_reason, is->is_reason, sizeof(iss.iss_reason));
197582babffbSEdward Tomasz Napierala 		strlcpy(iss.iss_offload, is->is_conn->ic_offload, sizeof(iss.iss_offload));
1976009ea47eSEdward Tomasz Napierala 
1977009ea47eSEdward Tomasz Napierala 		if (is->is_conn->ic_header_crc32c)
1978009ea47eSEdward Tomasz Napierala 			iss.iss_header_digest = ISCSI_DIGEST_CRC32C;
1979009ea47eSEdward Tomasz Napierala 		else
1980009ea47eSEdward Tomasz Napierala 			iss.iss_header_digest = ISCSI_DIGEST_NONE;
1981009ea47eSEdward Tomasz Napierala 
1982009ea47eSEdward Tomasz Napierala 		if (is->is_conn->ic_data_crc32c)
1983009ea47eSEdward Tomasz Napierala 			iss.iss_data_digest = ISCSI_DIGEST_CRC32C;
1984009ea47eSEdward Tomasz Napierala 		else
1985009ea47eSEdward Tomasz Napierala 			iss.iss_data_digest = ISCSI_DIGEST_NONE;
1986009ea47eSEdward Tomasz Napierala 
198797b84d34SNavdeep Parhar 		iss.iss_max_send_data_segment_length =
19880cc7d64aSJohn Baldwin 		    is->is_conn->ic_max_send_data_segment_length;
198997b84d34SNavdeep Parhar 		iss.iss_max_recv_data_segment_length =
19900cc7d64aSJohn Baldwin 		    is->is_conn->ic_max_recv_data_segment_length;
19914e5408f1SEdward Tomasz Napierala 		iss.iss_max_burst_length = is->is_max_burst_length;
19924e5408f1SEdward Tomasz Napierala 		iss.iss_first_burst_length = is->is_first_burst_length;
1993009ea47eSEdward Tomasz Napierala 		iss.iss_immediate_data = is->is_immediate_data;
1994009ea47eSEdward Tomasz Napierala 		iss.iss_connected = is->is_connected;
1995009ea47eSEdward Tomasz Napierala 
1996009ea47eSEdward Tomasz Napierala 		error = copyout(&iss, isl->isl_pstates + i, sizeof(iss));
1997009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1998009ea47eSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
1999009ea47eSEdward Tomasz Napierala 			return (error);
2000009ea47eSEdward Tomasz Napierala 		}
2001009ea47eSEdward Tomasz Napierala 		i++;
2002009ea47eSEdward Tomasz Napierala 	}
2003009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
2004009ea47eSEdward Tomasz Napierala 
2005009ea47eSEdward Tomasz Napierala 	isl->isl_nentries = i;
2006009ea47eSEdward Tomasz Napierala 
2007009ea47eSEdward Tomasz Napierala 	return (0);
2008009ea47eSEdward Tomasz Napierala }
2009009ea47eSEdward Tomasz Napierala 
2010009ea47eSEdward Tomasz Napierala static int
201151be90b5SEdward Tomasz Napierala iscsi_ioctl_session_modify(struct iscsi_softc *sc,
201251be90b5SEdward Tomasz Napierala     struct iscsi_session_modify *ism)
201351be90b5SEdward Tomasz Napierala {
201451be90b5SEdward Tomasz Napierala 	struct iscsi_session *is;
20158ff2372aSEdward Tomasz Napierala 	const struct iscsi_session *is2;
201651be90b5SEdward Tomasz Napierala 
201751be90b5SEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&ism->ism_conf);
201851be90b5SEdward Tomasz Napierala 	if (iscsi_valid_session_conf(&ism->ism_conf) == false)
201951be90b5SEdward Tomasz Napierala 		return (EINVAL);
202051be90b5SEdward Tomasz Napierala 
202151be90b5SEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
202251be90b5SEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
202351be90b5SEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
20248ff2372aSEdward Tomasz Napierala 		if (is->is_id == ism->ism_session_id) {
20258ff2372aSEdward Tomasz Napierala 			/* Note that the session remains locked. */
202651be90b5SEdward Tomasz Napierala 			break;
20278ff2372aSEdward Tomasz Napierala 		}
202851be90b5SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
202951be90b5SEdward Tomasz Napierala 	}
203051be90b5SEdward Tomasz Napierala 	if (is == NULL) {
203151be90b5SEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
203251be90b5SEdward Tomasz Napierala 		return (ESRCH);
203351be90b5SEdward Tomasz Napierala 	}
20348ff2372aSEdward Tomasz Napierala 
20358ff2372aSEdward Tomasz Napierala 	/*
20368ff2372aSEdward Tomasz Napierala 	 * Prevent duplicates.
20378ff2372aSEdward Tomasz Napierala 	 */
20388ff2372aSEdward Tomasz Napierala 	TAILQ_FOREACH(is2, &sc->sc_sessions, is_next) {
20398ff2372aSEdward Tomasz Napierala 		if (is == is2)
20408ff2372aSEdward Tomasz Napierala 			continue;
20418ff2372aSEdward Tomasz Napierala 
20428ff2372aSEdward Tomasz Napierala 		if (!!ism->ism_conf.isc_discovery !=
20438ff2372aSEdward Tomasz Napierala 		    !!is2->is_conf.isc_discovery)
20448ff2372aSEdward Tomasz Napierala 			continue;
20458ff2372aSEdward Tomasz Napierala 
20468ff2372aSEdward Tomasz Napierala 		if (strcmp(ism->ism_conf.isc_target_addr,
20478ff2372aSEdward Tomasz Napierala 		    is2->is_conf.isc_target_addr) != 0)
20488ff2372aSEdward Tomasz Napierala 			continue;
20498ff2372aSEdward Tomasz Napierala 
20508ff2372aSEdward Tomasz Napierala 		if (ism->ism_conf.isc_discovery == 0 &&
20518ff2372aSEdward Tomasz Napierala 		    strcmp(ism->ism_conf.isc_target,
20528ff2372aSEdward Tomasz Napierala 		    is2->is_conf.isc_target) != 0)
20538ff2372aSEdward Tomasz Napierala 			continue;
20548ff2372aSEdward Tomasz Napierala 
20558ff2372aSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
20568ff2372aSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
20578ff2372aSEdward Tomasz Napierala 		return (EBUSY);
20588ff2372aSEdward Tomasz Napierala 	}
20598ff2372aSEdward Tomasz Napierala 
206051be90b5SEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
206151be90b5SEdward Tomasz Napierala 
206251be90b5SEdward Tomasz Napierala 	memcpy(&is->is_conf, &ism->ism_conf, sizeof(is->is_conf));
206351be90b5SEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
206451be90b5SEdward Tomasz Napierala 
206551be90b5SEdward Tomasz Napierala 	iscsi_session_reconnect(is);
206651be90b5SEdward Tomasz Napierala 
206751be90b5SEdward Tomasz Napierala 	return (0);
206851be90b5SEdward Tomasz Napierala }
206951be90b5SEdward Tomasz Napierala 
207051be90b5SEdward Tomasz Napierala static int
2071009ea47eSEdward Tomasz Napierala iscsi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
2072009ea47eSEdward Tomasz Napierala     struct thread *td)
2073009ea47eSEdward Tomasz Napierala {
2074009ea47eSEdward Tomasz Napierala 	struct iscsi_softc *sc;
2075009ea47eSEdward Tomasz Napierala 
2076009ea47eSEdward Tomasz Napierala 	sc = dev->si_drv1;
2077009ea47eSEdward Tomasz Napierala 
2078009ea47eSEdward Tomasz Napierala 	switch (cmd) {
2079009ea47eSEdward Tomasz Napierala 	case ISCSIDWAIT:
2080009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_wait(sc,
2081009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_request *)arg));
2082009ea47eSEdward Tomasz Napierala 	case ISCSIDHANDOFF:
2083009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_handoff(sc,
2084009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_handoff *)arg));
2085009ea47eSEdward Tomasz Napierala 	case ISCSIDFAIL:
2086009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_fail(sc,
2087009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_fail *)arg));
2088009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
2089009ea47eSEdward Tomasz Napierala 	case ISCSIDCONNECT:
2090009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_connect(sc,
2091009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_connect *)arg));
2092009ea47eSEdward Tomasz Napierala 	case ISCSIDSEND:
2093009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_send(sc,
2094009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_send *)arg));
2095009ea47eSEdward Tomasz Napierala 	case ISCSIDRECEIVE:
2096009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_receive(sc,
2097009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_receive *)arg));
2098009ea47eSEdward Tomasz Napierala #endif /* ICL_KERNEL_PROXY */
2099009ea47eSEdward Tomasz Napierala 	case ISCSISADD:
2100009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_add(sc,
2101009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_add *)arg));
2102009ea47eSEdward Tomasz Napierala 	case ISCSISREMOVE:
2103009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_remove(sc,
2104009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_remove *)arg));
2105009ea47eSEdward Tomasz Napierala 	case ISCSISLIST:
2106009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_list(sc,
2107009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_list *)arg));
210851be90b5SEdward Tomasz Napierala 	case ISCSISMODIFY:
210951be90b5SEdward Tomasz Napierala 		return (iscsi_ioctl_session_modify(sc,
211051be90b5SEdward Tomasz Napierala 		    (struct iscsi_session_modify *)arg));
2111009ea47eSEdward Tomasz Napierala 	default:
2112009ea47eSEdward Tomasz Napierala 		return (EINVAL);
2113009ea47eSEdward Tomasz Napierala 	}
2114009ea47eSEdward Tomasz Napierala }
2115009ea47eSEdward Tomasz Napierala 
2116009ea47eSEdward Tomasz Napierala static struct iscsi_outstanding *
2117009ea47eSEdward Tomasz Napierala iscsi_outstanding_find(struct iscsi_session *is, uint32_t initiator_task_tag)
2118009ea47eSEdward Tomasz Napierala {
2119009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
2120009ea47eSEdward Tomasz Napierala 
2121009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2122009ea47eSEdward Tomasz Napierala 
2123009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2124009ea47eSEdward Tomasz Napierala 		if (io->io_initiator_task_tag == initiator_task_tag)
2125009ea47eSEdward Tomasz Napierala 			return (io);
2126009ea47eSEdward Tomasz Napierala 	}
2127009ea47eSEdward Tomasz Napierala 	return (NULL);
2128009ea47eSEdward Tomasz Napierala }
2129009ea47eSEdward Tomasz Napierala 
2130aa75114cSAlexander Motin static struct iscsi_outstanding *
2131aa75114cSAlexander Motin iscsi_outstanding_find_ccb(struct iscsi_session *is, union ccb *ccb)
2132aa75114cSAlexander Motin {
2133aa75114cSAlexander Motin 	struct iscsi_outstanding *io;
2134aa75114cSAlexander Motin 
2135aa75114cSAlexander Motin 	ISCSI_SESSION_LOCK_ASSERT(is);
2136aa75114cSAlexander Motin 
2137aa75114cSAlexander Motin 	TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2138aa75114cSAlexander Motin 		if (io->io_ccb == ccb)
2139aa75114cSAlexander Motin 			return (io);
2140aa75114cSAlexander Motin 	}
2141aa75114cSAlexander Motin 	return (NULL);
2142aa75114cSAlexander Motin }
2143aa75114cSAlexander Motin 
2144aa75114cSAlexander Motin static struct iscsi_outstanding *
2145604c023fSEdward Tomasz Napierala iscsi_outstanding_add(struct iscsi_session *is, struct icl_pdu *request,
21467a03d007SEdward Tomasz Napierala     union ccb *ccb, uint32_t *initiator_task_tagp)
2147009ea47eSEdward Tomasz Napierala {
2148009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
21497a03d007SEdward Tomasz Napierala 	int error;
2150009ea47eSEdward Tomasz Napierala 
2151009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2152009ea47eSEdward Tomasz Napierala 
2153009ea47eSEdward Tomasz Napierala 	io = uma_zalloc(iscsi_outstanding_zone, M_NOWAIT | M_ZERO);
2154009ea47eSEdward Tomasz Napierala 	if (io == NULL) {
21557a03d007SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate %zd bytes",
21567a03d007SEdward Tomasz Napierala 		    sizeof(*io));
2157aa75114cSAlexander Motin 		return (NULL);
2158009ea47eSEdward Tomasz Napierala 	}
21597a03d007SEdward Tomasz Napierala 
2160604c023fSEdward Tomasz Napierala 	error = icl_conn_task_setup(is->is_conn, request, &ccb->csio,
21617a03d007SEdward Tomasz Napierala 	    initiator_task_tagp, &io->io_icl_prv);
21627a03d007SEdward Tomasz Napierala 	if (error != 0) {
21637a03d007SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is,
21647a03d007SEdward Tomasz Napierala 		    "icl_conn_task_setup() failed with error %d", error);
21657a03d007SEdward Tomasz Napierala 		uma_zfree(iscsi_outstanding_zone, io);
21667a03d007SEdward Tomasz Napierala 		return (NULL);
21677a03d007SEdward Tomasz Napierala 	}
21687a03d007SEdward Tomasz Napierala 
21697a03d007SEdward Tomasz Napierala 	KASSERT(iscsi_outstanding_find(is, *initiator_task_tagp) == NULL,
21707a03d007SEdward Tomasz Napierala 	    ("initiator_task_tag 0x%x already added", *initiator_task_tagp));
21717a03d007SEdward Tomasz Napierala 
21727a03d007SEdward Tomasz Napierala 	io->io_initiator_task_tag = *initiator_task_tagp;
2173009ea47eSEdward Tomasz Napierala 	io->io_ccb = ccb;
2174009ea47eSEdward Tomasz Napierala 	TAILQ_INSERT_TAIL(&is->is_outstanding, io, io_next);
2175aa75114cSAlexander Motin 	return (io);
2176009ea47eSEdward Tomasz Napierala }
2177009ea47eSEdward Tomasz Napierala 
2178009ea47eSEdward Tomasz Napierala static void
2179009ea47eSEdward Tomasz Napierala iscsi_outstanding_remove(struct iscsi_session *is, struct iscsi_outstanding *io)
2180009ea47eSEdward Tomasz Napierala {
2181009ea47eSEdward Tomasz Napierala 
2182009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2183009ea47eSEdward Tomasz Napierala 
21847a03d007SEdward Tomasz Napierala 	icl_conn_task_done(is->is_conn, io->io_icl_prv);
2185009ea47eSEdward Tomasz Napierala 	TAILQ_REMOVE(&is->is_outstanding, io, io_next);
2186009ea47eSEdward Tomasz Napierala 	uma_zfree(iscsi_outstanding_zone, io);
2187009ea47eSEdward Tomasz Napierala }
2188009ea47eSEdward Tomasz Napierala 
2189009ea47eSEdward Tomasz Napierala static void
2190aa75114cSAlexander Motin iscsi_action_abort(struct iscsi_session *is, union ccb *ccb)
2191aa75114cSAlexander Motin {
2192aa75114cSAlexander Motin 	struct icl_pdu *request;
2193aa75114cSAlexander Motin 	struct iscsi_bhs_task_management_request *bhstmr;
2194aa75114cSAlexander Motin 	struct ccb_abort *cab = &ccb->cab;
2195aa75114cSAlexander Motin 	struct iscsi_outstanding *io, *aio;
21967a03d007SEdward Tomasz Napierala 	uint32_t initiator_task_tag;
2197aa75114cSAlexander Motin 
2198aa75114cSAlexander Motin 	ISCSI_SESSION_LOCK_ASSERT(is);
2199aa75114cSAlexander Motin 
2200aa75114cSAlexander Motin #if 0
2201aa75114cSAlexander Motin 	KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2202aa75114cSAlexander Motin #else
2203aa75114cSAlexander Motin 	if (is->is_login_phase) {
2204aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_ABORTED;
2205aa75114cSAlexander Motin 		xpt_done(ccb);
2206aa75114cSAlexander Motin 		return;
2207aa75114cSAlexander Motin 	}
2208aa75114cSAlexander Motin #endif
2209aa75114cSAlexander Motin 
2210aa75114cSAlexander Motin 	aio = iscsi_outstanding_find_ccb(is, cab->abort_ccb);
2211aa75114cSAlexander Motin 	if (aio == NULL) {
2212aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
2213aa75114cSAlexander Motin 		xpt_done(ccb);
2214aa75114cSAlexander Motin 		return;
2215aa75114cSAlexander Motin 	}
2216aa75114cSAlexander Motin 
2217d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
2218aa75114cSAlexander Motin 	if (request == NULL) {
2219aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
2220aa75114cSAlexander Motin 		xpt_done(ccb);
2221aa75114cSAlexander Motin 		return;
2222aa75114cSAlexander Motin 	}
2223aa75114cSAlexander Motin 
22247a03d007SEdward Tomasz Napierala 	initiator_task_tag = is->is_initiator_task_tag++;
22259bee9a98SAlexander Motin 	if (initiator_task_tag == 0xffffffff)
22269bee9a98SAlexander Motin 		initiator_task_tag = is->is_initiator_task_tag++;
2227aa75114cSAlexander Motin 
2228604c023fSEdward Tomasz Napierala 	io = iscsi_outstanding_add(is, request, NULL, &initiator_task_tag);
2229aa75114cSAlexander Motin 	if (io == NULL) {
2230aa75114cSAlexander Motin 		icl_pdu_free(request);
2231aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
2232aa75114cSAlexander Motin 		xpt_done(ccb);
2233aa75114cSAlexander Motin 		return;
2234aa75114cSAlexander Motin 	}
22353dd2a7a5SAlexander Motin 	io->io_referenced_task_tag = aio->io_initiator_task_tag;
22367a03d007SEdward Tomasz Napierala 
22377a03d007SEdward Tomasz Napierala 	bhstmr = (struct iscsi_bhs_task_management_request *)request->ip_bhs;
22387a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_opcode = ISCSI_BHS_OPCODE_TASK_REQUEST;
22397a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_function = 0x80 | BHSTMR_FUNCTION_ABORT_TASK;
22407a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_lun = htobe64(CAM_EXTLUN_BYTE_SWIZZLE(ccb->ccb_h.target_lun));
22417a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_initiator_task_tag = initiator_task_tag;
22427a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_referenced_task_tag = aio->io_initiator_task_tag;
22437a03d007SEdward Tomasz Napierala 
2244aa75114cSAlexander Motin 	iscsi_pdu_queue_locked(request);
2245aa75114cSAlexander Motin }
2246aa75114cSAlexander Motin 
2247aa75114cSAlexander Motin static void
2248009ea47eSEdward Tomasz Napierala iscsi_action_scsiio(struct iscsi_session *is, union ccb *ccb)
2249009ea47eSEdward Tomasz Napierala {
2250009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
2251009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_command *bhssc;
2252009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
2253aa75114cSAlexander Motin 	struct iscsi_outstanding *io;
2254009ea47eSEdward Tomasz Napierala 	size_t len;
22557a03d007SEdward Tomasz Napierala 	uint32_t initiator_task_tag;
2256009ea47eSEdward Tomasz Napierala 	int error;
2257009ea47eSEdward Tomasz Napierala 
2258009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2259009ea47eSEdward Tomasz Napierala 
2260009ea47eSEdward Tomasz Napierala #if 0
2261009ea47eSEdward Tomasz Napierala 	KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2262009ea47eSEdward Tomasz Napierala #else
2263009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
2264009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "called during login phase");
2265009ea47eSEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2266009ea47eSEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
2267009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
2268009ea47eSEdward Tomasz Napierala 		}
2269009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_ABORTED | CAM_DEV_QFRZN;
2270009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2271009ea47eSEdward Tomasz Napierala 		return;
2272009ea47eSEdward Tomasz Napierala 	}
2273009ea47eSEdward Tomasz Napierala #endif
2274009ea47eSEdward Tomasz Napierala 
2275d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
2276009ea47eSEdward Tomasz Napierala 	if (request == NULL) {
2277009ea47eSEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2278009ea47eSEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
2279009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
2280009ea47eSEdward Tomasz Napierala 		}
2281009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
2282009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2283009ea47eSEdward Tomasz Napierala 		return;
2284009ea47eSEdward Tomasz Napierala 	}
2285009ea47eSEdward Tomasz Napierala 
22867a03d007SEdward Tomasz Napierala 	initiator_task_tag = is->is_initiator_task_tag++;
22879bee9a98SAlexander Motin 	if (initiator_task_tag == 0xffffffff)
22889bee9a98SAlexander Motin 		initiator_task_tag = is->is_initiator_task_tag++;
22899bee9a98SAlexander Motin 
2290604c023fSEdward Tomasz Napierala 	io = iscsi_outstanding_add(is, request, ccb, &initiator_task_tag);
22917a03d007SEdward Tomasz Napierala 	if (io == NULL) {
22927a03d007SEdward Tomasz Napierala 		icl_pdu_free(request);
22937a03d007SEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
22947a03d007SEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
22957a03d007SEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
22967a03d007SEdward Tomasz Napierala 		}
22977a03d007SEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
22987a03d007SEdward Tomasz Napierala 		xpt_done(ccb);
22997a03d007SEdward Tomasz Napierala 		return;
23007a03d007SEdward Tomasz Napierala 	}
23017a03d007SEdward Tomasz Napierala 
2302009ea47eSEdward Tomasz Napierala 	csio = &ccb->csio;
2303009ea47eSEdward Tomasz Napierala 	bhssc = (struct iscsi_bhs_scsi_command *)request->ip_bhs;
2304009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_opcode = ISCSI_BHS_OPCODE_SCSI_COMMAND;
2305009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_flags |= BHSSC_FLAGS_F;
2306009ea47eSEdward Tomasz Napierala 	switch (csio->ccb_h.flags & CAM_DIR_MASK) {
2307009ea47eSEdward Tomasz Napierala 	case CAM_DIR_IN:
2308009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_flags |= BHSSC_FLAGS_R;
2309009ea47eSEdward Tomasz Napierala 		break;
2310009ea47eSEdward Tomasz Napierala 	case CAM_DIR_OUT:
2311009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_flags |= BHSSC_FLAGS_W;
2312009ea47eSEdward Tomasz Napierala 		break;
2313009ea47eSEdward Tomasz Napierala 	}
2314009ea47eSEdward Tomasz Napierala 
2315462cf3baSAlexander Motin 	if ((ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0) {
2316009ea47eSEdward Tomasz Napierala 		switch (csio->tag_action) {
2317009ea47eSEdward Tomasz Napierala 		case MSG_HEAD_OF_Q_TAG:
2318009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_HOQ;
2319009ea47eSEdward Tomasz Napierala 			break;
2320009ea47eSEdward Tomasz Napierala 		case MSG_ORDERED_Q_TAG:
2321009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_ORDERED;
2322009ea47eSEdward Tomasz Napierala 			break;
2323009ea47eSEdward Tomasz Napierala 		case MSG_ACA_TASK:
2324009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_ACA;
2325009ea47eSEdward Tomasz Napierala 			break;
2326009ea47eSEdward Tomasz Napierala 		case MSG_SIMPLE_Q_TAG:
2327009ea47eSEdward Tomasz Napierala 		default:
2328009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_SIMPLE;
2329009ea47eSEdward Tomasz Napierala 			break;
2330009ea47eSEdward Tomasz Napierala 		}
2331462cf3baSAlexander Motin 	} else
2332462cf3baSAlexander Motin 		bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_UNTAGGED;
2333009ea47eSEdward Tomasz Napierala 
233488364968SAlexander Motin 	if (is->is_protocol_level >= 2) {
233588364968SAlexander Motin 		bhssc->bhssc_pri = (csio->priority << BHSSC_PRI_SHIFT) &
233688364968SAlexander Motin 		    BHSSC_PRI_MASK;
233788364968SAlexander Motin 	}
233888364968SAlexander Motin 
2339a9f2f291SEdward Tomasz Napierala 	bhssc->bhssc_lun = htobe64(CAM_EXTLUN_BYTE_SWIZZLE(ccb->ccb_h.target_lun));
23407a03d007SEdward Tomasz Napierala 	bhssc->bhssc_initiator_task_tag = initiator_task_tag;
2341009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_expected_data_transfer_length = htonl(csio->dxfer_len);
2342009ea47eSEdward Tomasz Napierala 	KASSERT(csio->cdb_len <= sizeof(bhssc->bhssc_cdb),
2343009ea47eSEdward Tomasz Napierala 	    ("unsupported CDB size %zd", (size_t)csio->cdb_len));
2344009ea47eSEdward Tomasz Napierala 
2345009ea47eSEdward Tomasz Napierala 	if (csio->ccb_h.flags & CAM_CDB_POINTER)
2346009ea47eSEdward Tomasz Napierala 		memcpy(&bhssc->bhssc_cdb, csio->cdb_io.cdb_ptr, csio->cdb_len);
2347009ea47eSEdward Tomasz Napierala 	else
2348009ea47eSEdward Tomasz Napierala 		memcpy(&bhssc->bhssc_cdb, csio->cdb_io.cdb_bytes, csio->cdb_len);
2349009ea47eSEdward Tomasz Napierala 
2350009ea47eSEdward Tomasz Napierala 	if (is->is_immediate_data &&
2351009ea47eSEdward Tomasz Napierala 	    (csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
2352009ea47eSEdward Tomasz Napierala 		len = csio->dxfer_len;
2353009ea47eSEdward Tomasz Napierala 		//ISCSI_SESSION_DEBUG(is, "adding %zd of immediate data", len);
2354009ea47eSEdward Tomasz Napierala 		if (len > is->is_first_burst_length) {
235597b84d34SNavdeep Parhar 			ISCSI_SESSION_DEBUG(is, "len %zd -> %d", len, is->is_first_burst_length);
2356009ea47eSEdward Tomasz Napierala 			len = is->is_first_burst_length;
2357009ea47eSEdward Tomasz Napierala 		}
23580cc7d64aSJohn Baldwin 		if (len > is->is_conn->ic_max_send_data_segment_length) {
235997b84d34SNavdeep Parhar 			ISCSI_SESSION_DEBUG(is, "len %zd -> %d", len,
23600cc7d64aSJohn Baldwin 			    is->is_conn->ic_max_send_data_segment_length);
23610cc7d64aSJohn Baldwin 			len = is->is_conn->ic_max_send_data_segment_length;
23623f9e1172SAlexander Motin 		}
2363009ea47eSEdward Tomasz Napierala 
2364009ea47eSEdward Tomasz Napierala 		error = icl_pdu_append_data(request, csio->data_ptr, len, M_NOWAIT);
2365009ea47eSEdward Tomasz Napierala 		if (error != 0) {
2366938bcb04SEdward Tomasz Napierala 			iscsi_outstanding_remove(is, io);
2367009ea47eSEdward Tomasz Napierala 			icl_pdu_free(request);
2368009ea47eSEdward Tomasz Napierala 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2369009ea47eSEdward Tomasz Napierala 				xpt_freeze_devq(ccb->ccb_h.path, 1);
2370009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
2371009ea47eSEdward Tomasz Napierala 			}
2372009ea47eSEdward Tomasz Napierala 			ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
2373009ea47eSEdward Tomasz Napierala 			xpt_done(ccb);
2374009ea47eSEdward Tomasz Napierala 			return;
2375009ea47eSEdward Tomasz Napierala 		}
2376009ea47eSEdward Tomasz Napierala 	}
2377009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
2378009ea47eSEdward Tomasz Napierala }
2379009ea47eSEdward Tomasz Napierala 
2380009ea47eSEdward Tomasz Napierala static void
2381009ea47eSEdward Tomasz Napierala iscsi_action(struct cam_sim *sim, union ccb *ccb)
2382009ea47eSEdward Tomasz Napierala {
2383009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
2384009ea47eSEdward Tomasz Napierala 
2385009ea47eSEdward Tomasz Napierala 	is = cam_sim_softc(sim);
2386009ea47eSEdward Tomasz Napierala 
2387009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2388009ea47eSEdward Tomasz Napierala 
2389f1f12e40SEdward Tomasz Napierala 	if (is->is_terminating ||
2390f1f12e40SEdward Tomasz Napierala 	    (is->is_connected == false && fail_on_disconnection)) {
2391009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2392009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2393009ea47eSEdward Tomasz Napierala 		return;
2394009ea47eSEdward Tomasz Napierala 	}
2395009ea47eSEdward Tomasz Napierala 
2396186bcdaaSEdward Tomasz Napierala 	/*
2397186bcdaaSEdward Tomasz Napierala 	 * Make sure CAM doesn't sneak in a CCB just after freezing the queue.
2398186bcdaaSEdward Tomasz Napierala 	 */
2399186bcdaaSEdward Tomasz Napierala 	if (is->is_simq_frozen == true) {
2400186bcdaaSEdward Tomasz Napierala 		ccb->ccb_h.status &= ~(CAM_SIM_QUEUED | CAM_STATUS_MASK);
2401186bcdaaSEdward Tomasz Napierala 		ccb->ccb_h.status |= CAM_REQUEUE_REQ;
2402186bcdaaSEdward Tomasz Napierala 		/* Don't freeze the devq - the SIM queue is already frozen. */
2403186bcdaaSEdward Tomasz Napierala 		xpt_done(ccb);
2404186bcdaaSEdward Tomasz Napierala 		return;
2405186bcdaaSEdward Tomasz Napierala 	}
2406186bcdaaSEdward Tomasz Napierala 
2407009ea47eSEdward Tomasz Napierala 	switch (ccb->ccb_h.func_code) {
2408009ea47eSEdward Tomasz Napierala 	case XPT_PATH_INQ:
2409009ea47eSEdward Tomasz Napierala 	{
2410009ea47eSEdward Tomasz Napierala 		struct ccb_pathinq *cpi = &ccb->cpi;
2411009ea47eSEdward Tomasz Napierala 
2412009ea47eSEdward Tomasz Napierala 		cpi->version_num = 1;
2413009ea47eSEdward Tomasz Napierala 		cpi->hba_inquiry = PI_TAG_ABLE;
2414009ea47eSEdward Tomasz Napierala 		cpi->target_sprt = 0;
2415a9f2f291SEdward Tomasz Napierala 		cpi->hba_misc = PIM_EXTLUNS;
24167deb68abSEdward Tomasz Napierala 		/*
24177deb68abSEdward Tomasz Napierala 		 * XXX: It shouldn't ever be NULL; this could be turned
24187deb68abSEdward Tomasz Napierala 		 *      into a KASSERT eventually.
24197deb68abSEdward Tomasz Napierala 		 */
24207deb68abSEdward Tomasz Napierala 		if (is->is_conn == NULL)
24217deb68abSEdward Tomasz Napierala 			ISCSI_WARN("NULL conn");
24227deb68abSEdward Tomasz Napierala 		else if (is->is_conn->ic_unmapped)
24237deb68abSEdward Tomasz Napierala 			cpi->hba_misc |= PIM_UNMAPPED;
2424009ea47eSEdward Tomasz Napierala 		cpi->hba_eng_cnt = 0;
2425009ea47eSEdward Tomasz Napierala 		cpi->max_target = 0;
242617cf3eb1SEdward Tomasz Napierala 		/*
242717cf3eb1SEdward Tomasz Napierala 		 * Note that the variable below is only relevant for targets
242817cf3eb1SEdward Tomasz Napierala 		 * that don't claim compliance with anything above SPC2, which
242917cf3eb1SEdward Tomasz Napierala 		 * means they don't support REPORT_LUNS.
243017cf3eb1SEdward Tomasz Napierala 		 */
243117cf3eb1SEdward Tomasz Napierala 		cpi->max_lun = 255;
2432a9f2f291SEdward Tomasz Napierala 		cpi->initiator_id = ~0;
24337843bd03SEdward Tomasz Napierala 		strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
24347843bd03SEdward Tomasz Napierala 		strlcpy(cpi->hba_vid, "iSCSI", HBA_IDLEN);
24357843bd03SEdward Tomasz Napierala 		strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
2436009ea47eSEdward Tomasz Napierala 		cpi->unit_number = cam_sim_unit(sim);
2437009ea47eSEdward Tomasz Napierala 		cpi->bus_id = cam_sim_bus(sim);
2438009ea47eSEdward Tomasz Napierala 		cpi->base_transfer_speed = 150000; /* XXX */
2439009ea47eSEdward Tomasz Napierala 		cpi->transport = XPORT_ISCSI;
2440009ea47eSEdward Tomasz Napierala 		cpi->transport_version = 0;
2441009ea47eSEdward Tomasz Napierala 		cpi->protocol = PROTO_SCSI;
2442009ea47eSEdward Tomasz Napierala 		cpi->protocol_version = SCSI_REV_SPC3;
2443cd853791SKonstantin Belousov 		cpi->maxio = maxphys;
2444009ea47eSEdward Tomasz Napierala 		cpi->ccb_h.status = CAM_REQ_CMP;
2445009ea47eSEdward Tomasz Napierala 		break;
2446009ea47eSEdward Tomasz Napierala 	}
2447462cf3baSAlexander Motin 	case XPT_GET_TRAN_SETTINGS:
2448462cf3baSAlexander Motin 	{
2449462cf3baSAlexander Motin 		struct ccb_trans_settings	*cts;
2450462cf3baSAlexander Motin 		struct ccb_trans_settings_scsi	*scsi;
2451462cf3baSAlexander Motin 
2452462cf3baSAlexander Motin 		cts = &ccb->cts;
2453462cf3baSAlexander Motin 		scsi = &cts->proto_specific.scsi;
2454462cf3baSAlexander Motin 
2455462cf3baSAlexander Motin 		cts->protocol = PROTO_SCSI;
2456462cf3baSAlexander Motin 		cts->protocol_version = SCSI_REV_SPC3;
2457462cf3baSAlexander Motin 		cts->transport = XPORT_ISCSI;
2458462cf3baSAlexander Motin 		cts->transport_version = 0;
2459462cf3baSAlexander Motin 		scsi->valid = CTS_SCSI_VALID_TQ;
2460462cf3baSAlexander Motin 		scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
2461462cf3baSAlexander Motin 		cts->ccb_h.status = CAM_REQ_CMP;
2462462cf3baSAlexander Motin 		break;
2463462cf3baSAlexander Motin 	}
2464009ea47eSEdward Tomasz Napierala 	case XPT_CALC_GEOMETRY:
2465009ea47eSEdward Tomasz Napierala 		cam_calc_geometry(&ccb->ccg, /*extended*/1);
2466009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_CMP;
2467009ea47eSEdward Tomasz Napierala 		break;
2468009ea47eSEdward Tomasz Napierala #if 0
2469009ea47eSEdward Tomasz Napierala 	/*
2470009ea47eSEdward Tomasz Napierala 	 * XXX: What's the point?
2471009ea47eSEdward Tomasz Napierala 	 */
2472009ea47eSEdward Tomasz Napierala 	case XPT_RESET_BUS:
2473009ea47eSEdward Tomasz Napierala 	case XPT_TERM_IO:
2474009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "faking success for reset, abort, or term_io");
2475009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_CMP;
2476009ea47eSEdward Tomasz Napierala 		break;
2477009ea47eSEdward Tomasz Napierala #endif
2478aa75114cSAlexander Motin 	case XPT_ABORT:
2479aa75114cSAlexander Motin 		iscsi_action_abort(is, ccb);
2480aa75114cSAlexander Motin 		return;
2481009ea47eSEdward Tomasz Napierala 	case XPT_SCSI_IO:
2482009ea47eSEdward Tomasz Napierala 		iscsi_action_scsiio(is, ccb);
2483009ea47eSEdward Tomasz Napierala 		return;
2484009ea47eSEdward Tomasz Napierala 	default:
2485009ea47eSEdward Tomasz Napierala #if 0
2486009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "got unsupported code 0x%x", ccb->ccb_h.func_code);
2487009ea47eSEdward Tomasz Napierala #endif
2488009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
2489009ea47eSEdward Tomasz Napierala 		break;
2490009ea47eSEdward Tomasz Napierala 	}
2491009ea47eSEdward Tomasz Napierala 	xpt_done(ccb);
2492009ea47eSEdward Tomasz Napierala }
2493009ea47eSEdward Tomasz Napierala 
2494009ea47eSEdward Tomasz Napierala static void
2495481b36c6SSteven Hartland iscsi_terminate_sessions(struct iscsi_softc *sc)
2496009ea47eSEdward Tomasz Napierala {
2497009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
2498009ea47eSEdward Tomasz Napierala 
2499481b36c6SSteven Hartland 	sx_slock(&sc->sc_lock);
2500481b36c6SSteven Hartland 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next)
2501481b36c6SSteven Hartland 		iscsi_session_terminate(is);
2502481b36c6SSteven Hartland 	while(!TAILQ_EMPTY(&sc->sc_sessions)) {
2503481b36c6SSteven Hartland 		ISCSI_DEBUG("waiting for sessions to terminate");
2504481b36c6SSteven Hartland 		cv_wait(&sc->sc_cv, &sc->sc_lock);
2505481b36c6SSteven Hartland 	}
2506481b36c6SSteven Hartland 	ISCSI_DEBUG("all sessions terminated");
2507481b36c6SSteven Hartland 	sx_sunlock(&sc->sc_lock);
2508481b36c6SSteven Hartland }
2509481b36c6SSteven Hartland 
2510481b36c6SSteven Hartland static void
2511481b36c6SSteven Hartland iscsi_shutdown_pre(struct iscsi_softc *sc)
2512481b36c6SSteven Hartland {
2513481b36c6SSteven Hartland 	struct iscsi_session *is;
2514481b36c6SSteven Hartland 
2515481b36c6SSteven Hartland 	if (!fail_on_shutdown)
2516481b36c6SSteven Hartland 		return;
2517009ea47eSEdward Tomasz Napierala 
2518e553ca49SEdward Tomasz Napierala 	/*
2519e553ca49SEdward Tomasz Napierala 	 * If we have any sessions waiting for reconnection, request
2520e553ca49SEdward Tomasz Napierala 	 * maintenance thread to fail them immediately instead of waiting
2521e553ca49SEdward Tomasz Napierala 	 * for reconnect timeout.
2522481b36c6SSteven Hartland 	 *
2523481b36c6SSteven Hartland 	 * This prevents LUNs with mounted filesystems that are supported
2524481b36c6SSteven Hartland 	 * by disconnected iSCSI sessions from hanging, however it will
2525481b36c6SSteven Hartland 	 * fail all queued BIOs.
2526e553ca49SEdward Tomasz Napierala 	 */
2527481b36c6SSteven Hartland 	ISCSI_DEBUG("forcing failing all disconnected sessions due to shutdown");
2528481b36c6SSteven Hartland 
2529481b36c6SSteven Hartland 	fail_on_disconnection = 1;
2530481b36c6SSteven Hartland 
2531009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
2532e553ca49SEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
2533e553ca49SEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
2534481b36c6SSteven Hartland 		if (!is->is_connected) {
2535481b36c6SSteven Hartland 			ISCSI_SESSION_DEBUG(is, "force failing disconnected session early");
2536e553ca49SEdward Tomasz Napierala 			iscsi_session_reconnect(is);
2537481b36c6SSteven Hartland 		}
2538e553ca49SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
2539e553ca49SEdward Tomasz Napierala 	}
2540009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
2541009ea47eSEdward Tomasz Napierala }
2542009ea47eSEdward Tomasz Napierala 
2543481b36c6SSteven Hartland static void
2544481b36c6SSteven Hartland iscsi_shutdown_post(struct iscsi_softc *sc)
2545481b36c6SSteven Hartland {
2546481b36c6SSteven Hartland 
2547879e0604SMateusz Guzik 	if (!KERNEL_PANICKED()) {
2548481b36c6SSteven Hartland 		ISCSI_DEBUG("removing all sessions due to shutdown");
2549481b36c6SSteven Hartland 		iscsi_terminate_sessions(sc);
2550481b36c6SSteven Hartland 	}
2551e54fb4ffSAndriy Gapon }
2552481b36c6SSteven Hartland 
2553009ea47eSEdward Tomasz Napierala static int
2554009ea47eSEdward Tomasz Napierala iscsi_load(void)
2555009ea47eSEdward Tomasz Napierala {
2556009ea47eSEdward Tomasz Napierala 	int error;
2557009ea47eSEdward Tomasz Napierala 
2558009ea47eSEdward Tomasz Napierala 	sc = malloc(sizeof(*sc), M_ISCSI, M_ZERO | M_WAITOK);
2559009ea47eSEdward Tomasz Napierala 	sx_init(&sc->sc_lock, "iscsi");
2560009ea47eSEdward Tomasz Napierala 	TAILQ_INIT(&sc->sc_sessions);
2561009ea47eSEdward Tomasz Napierala 	cv_init(&sc->sc_cv, "iscsi_cv");
2562009ea47eSEdward Tomasz Napierala 
2563009ea47eSEdward Tomasz Napierala 	iscsi_outstanding_zone = uma_zcreate("iscsi_outstanding",
2564009ea47eSEdward Tomasz Napierala 	    sizeof(struct iscsi_outstanding), NULL, NULL, NULL, NULL,
2565c28c09c1SEdward Tomasz Napierala 	    UMA_ALIGN_PTR, 0);
2566009ea47eSEdward Tomasz Napierala 
2567009ea47eSEdward Tomasz Napierala 	error = make_dev_p(MAKEDEV_CHECKNAME, &sc->sc_cdev, &iscsi_cdevsw,
2568009ea47eSEdward Tomasz Napierala 	    NULL, UID_ROOT, GID_WHEEL, 0600, "iscsi");
2569009ea47eSEdward Tomasz Napierala 	if (error != 0) {
2570009ea47eSEdward Tomasz Napierala 		ISCSI_WARN("failed to create device node, error %d", error);
2571009ea47eSEdward Tomasz Napierala 		return (error);
2572009ea47eSEdward Tomasz Napierala 	}
2573009ea47eSEdward Tomasz Napierala 	sc->sc_cdev->si_drv1 = sc;
2574009ea47eSEdward Tomasz Napierala 
2575481b36c6SSteven Hartland 	sc->sc_shutdown_pre_eh = EVENTHANDLER_REGISTER(shutdown_pre_sync,
2576481b36c6SSteven Hartland 	    iscsi_shutdown_pre, sc, SHUTDOWN_PRI_FIRST);
2577481b36c6SSteven Hartland 	/*
2578481b36c6SSteven Hartland 	 * shutdown_post_sync needs to run after filesystem shutdown and before
2579481b36c6SSteven Hartland 	 * CAM shutdown - otherwise when rebooting with an iSCSI session that is
2580481b36c6SSteven Hartland 	 * disconnected but has outstanding requests, dashutdown() will hang on
2581481b36c6SSteven Hartland 	 * cam_periph_runccb().
2582481b36c6SSteven Hartland 	 */
2583481b36c6SSteven Hartland 	sc->sc_shutdown_post_eh = EVENTHANDLER_REGISTER(shutdown_post_sync,
2584481b36c6SSteven Hartland 	    iscsi_shutdown_post, sc, SHUTDOWN_PRI_DEFAULT - 1);
2585009ea47eSEdward Tomasz Napierala 
2586009ea47eSEdward Tomasz Napierala 	return (0);
2587009ea47eSEdward Tomasz Napierala }
2588009ea47eSEdward Tomasz Napierala 
2589009ea47eSEdward Tomasz Napierala static int
2590009ea47eSEdward Tomasz Napierala iscsi_unload(void)
2591009ea47eSEdward Tomasz Napierala {
2592009ea47eSEdward Tomasz Napierala 
259389df4847SJohn Baldwin 	/* Awaken any threads asleep in iscsi_ioctl(). */
259489df4847SJohn Baldwin 	sx_xlock(&sc->sc_lock);
259589df4847SJohn Baldwin 	sc->sc_unloading = true;
259689df4847SJohn Baldwin 	cv_signal(&sc->sc_cv);
259789df4847SJohn Baldwin 	sx_xunlock(&sc->sc_lock);
259889df4847SJohn Baldwin 
2599a667cf73SEdward Tomasz Napierala 	if (sc->sc_cdev != NULL) {
2600009ea47eSEdward Tomasz Napierala 		ISCSI_DEBUG("removing device node");
2601009ea47eSEdward Tomasz Napierala 		destroy_dev(sc->sc_cdev);
2602009ea47eSEdward Tomasz Napierala 		ISCSI_DEBUG("device node removed");
2603a667cf73SEdward Tomasz Napierala 	}
2604009ea47eSEdward Tomasz Napierala 
2605481b36c6SSteven Hartland 	if (sc->sc_shutdown_pre_eh != NULL)
2606481b36c6SSteven Hartland 		EVENTHANDLER_DEREGISTER(shutdown_pre_sync, sc->sc_shutdown_pre_eh);
2607481b36c6SSteven Hartland 	if (sc->sc_shutdown_post_eh != NULL)
2608481b36c6SSteven Hartland 		EVENTHANDLER_DEREGISTER(shutdown_post_sync, sc->sc_shutdown_post_eh);
2609009ea47eSEdward Tomasz Napierala 
2610481b36c6SSteven Hartland 	iscsi_terminate_sessions(sc);
2611009ea47eSEdward Tomasz Napierala 
2612009ea47eSEdward Tomasz Napierala 	uma_zdestroy(iscsi_outstanding_zone);
2613009ea47eSEdward Tomasz Napierala 	sx_destroy(&sc->sc_lock);
2614009ea47eSEdward Tomasz Napierala 	cv_destroy(&sc->sc_cv);
2615009ea47eSEdward Tomasz Napierala 	free(sc, M_ISCSI);
2616009ea47eSEdward Tomasz Napierala 	return (0);
2617009ea47eSEdward Tomasz Napierala }
2618009ea47eSEdward Tomasz Napierala 
2619009ea47eSEdward Tomasz Napierala static int
2620009ea47eSEdward Tomasz Napierala iscsi_quiesce(void)
2621009ea47eSEdward Tomasz Napierala {
2622009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
2623009ea47eSEdward Tomasz Napierala 	if (!TAILQ_EMPTY(&sc->sc_sessions)) {
2624009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
2625009ea47eSEdward Tomasz Napierala 		return (EBUSY);
2626009ea47eSEdward Tomasz Napierala 	}
2627009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
2628009ea47eSEdward Tomasz Napierala 	return (0);
2629009ea47eSEdward Tomasz Napierala }
2630009ea47eSEdward Tomasz Napierala 
2631009ea47eSEdward Tomasz Napierala static int
2632009ea47eSEdward Tomasz Napierala iscsi_modevent(module_t mod, int what, void *arg)
2633009ea47eSEdward Tomasz Napierala {
2634009ea47eSEdward Tomasz Napierala 	int error;
2635009ea47eSEdward Tomasz Napierala 
2636009ea47eSEdward Tomasz Napierala 	switch (what) {
2637009ea47eSEdward Tomasz Napierala 	case MOD_LOAD:
2638009ea47eSEdward Tomasz Napierala 		error = iscsi_load();
2639009ea47eSEdward Tomasz Napierala 		break;
2640009ea47eSEdward Tomasz Napierala 	case MOD_UNLOAD:
2641009ea47eSEdward Tomasz Napierala 		error = iscsi_unload();
2642009ea47eSEdward Tomasz Napierala 		break;
2643009ea47eSEdward Tomasz Napierala 	case MOD_QUIESCE:
2644009ea47eSEdward Tomasz Napierala 		error = iscsi_quiesce();
2645009ea47eSEdward Tomasz Napierala 		break;
2646009ea47eSEdward Tomasz Napierala 	default:
2647009ea47eSEdward Tomasz Napierala 		error = EINVAL;
2648009ea47eSEdward Tomasz Napierala 		break;
2649009ea47eSEdward Tomasz Napierala 	}
2650009ea47eSEdward Tomasz Napierala 	return (error);
2651009ea47eSEdward Tomasz Napierala }
2652009ea47eSEdward Tomasz Napierala 
2653009ea47eSEdward Tomasz Napierala moduledata_t iscsi_data = {
2654009ea47eSEdward Tomasz Napierala 	"iscsi",
2655009ea47eSEdward Tomasz Napierala 	iscsi_modevent,
2656009ea47eSEdward Tomasz Napierala 	0
2657009ea47eSEdward Tomasz Napierala };
2658009ea47eSEdward Tomasz Napierala 
2659009ea47eSEdward Tomasz Napierala DECLARE_MODULE(iscsi, iscsi_data, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
2660009ea47eSEdward Tomasz Napierala MODULE_DEPEND(iscsi, cam, 1, 1, 1);
2661009ea47eSEdward Tomasz Napierala MODULE_DEPEND(iscsi, icl, 1, 1, 1);
2662