xref: /freebsd/sys/dev/iscsi/iscsi.c (revision 2f0586b2ce5a8f582ad7c7388d056faeca194d6e)
1009ea47eSEdward Tomasz Napierala /*-
2009ea47eSEdward Tomasz Napierala  * Copyright (c) 2012 The FreeBSD Foundation
3009ea47eSEdward Tomasz Napierala  * All rights reserved.
4009ea47eSEdward Tomasz Napierala  *
5009ea47eSEdward Tomasz Napierala  * This software was developed by Edward Tomasz Napierala under sponsorship
6009ea47eSEdward Tomasz Napierala  * from the FreeBSD Foundation.
7009ea47eSEdward Tomasz Napierala  *
8009ea47eSEdward Tomasz Napierala  * Redistribution and use in source and binary forms, with or without
9009ea47eSEdward Tomasz Napierala  * modification, are permitted provided that the following conditions
10009ea47eSEdward Tomasz Napierala  * are met:
11009ea47eSEdward Tomasz Napierala  * 1. Redistributions of source code must retain the above copyright
12009ea47eSEdward Tomasz Napierala  *    notice, this list of conditions and the following disclaimer.
13009ea47eSEdward Tomasz Napierala  * 2. Redistributions in binary form must reproduce the above copyright
14009ea47eSEdward Tomasz Napierala  *    notice, this list of conditions and the following disclaimer in the
15009ea47eSEdward Tomasz Napierala  *    documentation and/or other materials provided with the distribution.
16009ea47eSEdward Tomasz Napierala  *
17009ea47eSEdward Tomasz Napierala  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18009ea47eSEdward Tomasz Napierala  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19009ea47eSEdward Tomasz Napierala  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20009ea47eSEdward Tomasz Napierala  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21009ea47eSEdward Tomasz Napierala  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22009ea47eSEdward Tomasz Napierala  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23009ea47eSEdward Tomasz Napierala  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24009ea47eSEdward Tomasz Napierala  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25009ea47eSEdward Tomasz Napierala  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26009ea47eSEdward Tomasz Napierala  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27009ea47eSEdward Tomasz Napierala  * SUCH DAMAGE.
28009ea47eSEdward Tomasz Napierala  *
29009ea47eSEdward Tomasz Napierala  */
30009ea47eSEdward Tomasz Napierala 
31b7a65e39SEdward Tomasz Napierala #include <sys/cdefs.h>
32b7a65e39SEdward Tomasz Napierala __FBSDID("$FreeBSD$");
33b7a65e39SEdward Tomasz Napierala 
34009ea47eSEdward Tomasz Napierala #include <sys/param.h>
35009ea47eSEdward Tomasz Napierala #include <sys/condvar.h>
36009ea47eSEdward Tomasz Napierala #include <sys/conf.h>
37a9f2f291SEdward Tomasz Napierala #include <sys/endian.h>
38009ea47eSEdward Tomasz Napierala #include <sys/eventhandler.h>
39009ea47eSEdward Tomasz Napierala #include <sys/file.h>
40009ea47eSEdward Tomasz Napierala #include <sys/kernel.h>
41009ea47eSEdward Tomasz Napierala #include <sys/kthread.h>
42009ea47eSEdward Tomasz Napierala #include <sys/lock.h>
43009ea47eSEdward Tomasz Napierala #include <sys/malloc.h>
44009ea47eSEdward Tomasz Napierala #include <sys/mutex.h>
45009ea47eSEdward Tomasz Napierala #include <sys/module.h>
46f41492b0SEdward Tomasz Napierala #include <sys/socket.h>
47009ea47eSEdward Tomasz Napierala #include <sys/sysctl.h>
48009ea47eSEdward Tomasz Napierala #include <sys/systm.h>
49009ea47eSEdward Tomasz Napierala #include <sys/sx.h>
50009ea47eSEdward Tomasz Napierala #include <vm/uma.h>
51009ea47eSEdward Tomasz Napierala 
52009ea47eSEdward Tomasz Napierala #include <cam/cam.h>
53009ea47eSEdward Tomasz Napierala #include <cam/cam_ccb.h>
54009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt.h>
55009ea47eSEdward Tomasz Napierala #include <cam/cam_debug.h>
56009ea47eSEdward Tomasz Napierala #include <cam/cam_sim.h>
57009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt_sim.h>
58009ea47eSEdward Tomasz Napierala #include <cam/cam_xpt_periph.h>
59009ea47eSEdward Tomasz Napierala #include <cam/cam_periph.h>
60009ea47eSEdward Tomasz Napierala #include <cam/scsi/scsi_all.h>
61009ea47eSEdward Tomasz Napierala #include <cam/scsi/scsi_message.h>
62009ea47eSEdward Tomasz Napierala 
63ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/icl.h>
64321b17ecSEdward Tomasz Napierala #include <dev/iscsi/icl_wrappers.h>
65ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi_ioctl.h>
66ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi_proto.h>
67ddc5fd90SEdward Tomasz Napierala #include <dev/iscsi/iscsi.h>
68009ea47eSEdward Tomasz Napierala 
69009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
70009ea47eSEdward Tomasz Napierala #include <sys/socketvar.h>
71009ea47eSEdward Tomasz Napierala #endif
72009ea47eSEdward Tomasz Napierala 
732ebde326SEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
742ebde326SEdward Tomasz Napierala FEATURE(iscsi_kernel_proxy, "iSCSI initiator built with ICL_KERNEL_PROXY");
752ebde326SEdward Tomasz Napierala #endif
762ebde326SEdward Tomasz Napierala 
77009ea47eSEdward Tomasz Napierala /*
78009ea47eSEdward Tomasz Napierala  * XXX: This is global so the iscsi_unload() can access it.
79009ea47eSEdward Tomasz Napierala  * 	Think about how to do this properly.
80009ea47eSEdward Tomasz Napierala  */
81009ea47eSEdward Tomasz Napierala static struct iscsi_softc	*sc;
82009ea47eSEdward Tomasz Napierala 
83009ea47eSEdward Tomasz Napierala SYSCTL_NODE(_kern, OID_AUTO, iscsi, CTLFLAG_RD, 0, "iSCSI initiator");
84009ea47eSEdward Tomasz Napierala static int debug = 1;
85605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, debug, CTLFLAG_RWTUN,
861f6b2af2SAlexander Motin     &debug, 0, "Enable debug messages");
87009ea47eSEdward Tomasz Napierala static int ping_timeout = 5;
88605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, ping_timeout, CTLFLAG_RWTUN, &ping_timeout,
891f6b2af2SAlexander Motin     0, "Timeout for ping (NOP-Out) requests, in seconds");
90009ea47eSEdward Tomasz Napierala static int iscsid_timeout = 60;
91605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, iscsid_timeout, CTLFLAG_RWTUN, &iscsid_timeout,
921f6b2af2SAlexander Motin     0, "Time to wait for iscsid(8) to handle reconnection, in seconds");
93009ea47eSEdward Tomasz Napierala static int login_timeout = 60;
94605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, login_timeout, CTLFLAG_RWTUN, &login_timeout,
951f6b2af2SAlexander Motin     0, "Time to wait for iscsid(8) to finish Login Phase, in seconds");
96009ea47eSEdward Tomasz Napierala static int maxtags = 255;
97605a34b0SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, maxtags, CTLFLAG_RWTUN, &maxtags,
981f6b2af2SAlexander Motin     0, "Max number of IO requests queued");
99f1f12e40SEdward Tomasz Napierala static int fail_on_disconnection = 0;
100f1f12e40SEdward Tomasz Napierala SYSCTL_INT(_kern_iscsi, OID_AUTO, fail_on_disconnection, CTLFLAG_RWTUN,
101f1f12e40SEdward Tomasz Napierala     &fail_on_disconnection, 0, "Destroy CAM SIM on connection failure");
102481b36c6SSteven Hartland static int fail_on_shutdown = 1;
103481b36c6SSteven Hartland SYSCTL_INT(_kern_iscsi, OID_AUTO, fail_on_shutdown, CTLFLAG_RWTUN,
104481b36c6SSteven Hartland     &fail_on_shutdown, 0, "Fail disconnected sessions on shutdown");
105009ea47eSEdward Tomasz Napierala 
106009ea47eSEdward Tomasz Napierala static MALLOC_DEFINE(M_ISCSI, "iSCSI", "iSCSI initiator");
107009ea47eSEdward Tomasz Napierala static uma_zone_t iscsi_outstanding_zone;
108009ea47eSEdward Tomasz Napierala 
109009ea47eSEdward Tomasz Napierala #define	CONN_SESSION(X)	((struct iscsi_session *)X->ic_prv0)
110009ea47eSEdward Tomasz Napierala #define	PDU_SESSION(X)	(CONN_SESSION(X->ip_conn))
111009ea47eSEdward Tomasz Napierala 
112009ea47eSEdward Tomasz Napierala #define	ISCSI_DEBUG(X, ...)						\
113b1277ad1SEdward Tomasz Napierala 	do {								\
114b1277ad1SEdward Tomasz Napierala 		if (debug > 1) 						\
115009ea47eSEdward Tomasz Napierala 			printf("%s: " X "\n", __func__, ## __VA_ARGS__);\
116009ea47eSEdward Tomasz Napierala 	} while (0)
117009ea47eSEdward Tomasz Napierala 
118009ea47eSEdward Tomasz Napierala #define	ISCSI_WARN(X, ...)						\
119b1277ad1SEdward Tomasz Napierala 	do {								\
120009ea47eSEdward Tomasz Napierala 		if (debug > 0) {					\
121009ea47eSEdward Tomasz Napierala 			printf("WARNING: %s: " X "\n",			\
122009ea47eSEdward Tomasz Napierala 			    __func__, ## __VA_ARGS__);			\
123b1277ad1SEdward Tomasz Napierala 		}							\
124009ea47eSEdward Tomasz Napierala 	} while (0)
125009ea47eSEdward Tomasz Napierala 
126009ea47eSEdward Tomasz Napierala #define	ISCSI_SESSION_DEBUG(S, X, ...)					\
127b1277ad1SEdward Tomasz Napierala 	do {								\
128009ea47eSEdward Tomasz Napierala 		if (debug > 1) {					\
129009ea47eSEdward Tomasz Napierala 			printf("%s: %s (%s): " X "\n",			\
130009ea47eSEdward Tomasz Napierala 			    __func__, S->is_conf.isc_target_addr,	\
131009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target, ## __VA_ARGS__);	\
132b1277ad1SEdward Tomasz Napierala 		}							\
133009ea47eSEdward Tomasz Napierala 	} while (0)
134009ea47eSEdward Tomasz Napierala 
135009ea47eSEdward Tomasz Napierala #define	ISCSI_SESSION_WARN(S, X, ...)					\
136b1277ad1SEdward Tomasz Napierala 	do {								\
137009ea47eSEdward Tomasz Napierala 		if (debug > 0) {					\
138009ea47eSEdward Tomasz Napierala 			printf("WARNING: %s (%s): " X "\n",		\
139009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target_addr,			\
140009ea47eSEdward Tomasz Napierala 			    S->is_conf.isc_target, ## __VA_ARGS__);	\
141b1277ad1SEdward Tomasz Napierala 		}							\
142009ea47eSEdward Tomasz Napierala 	} while (0)
143009ea47eSEdward Tomasz Napierala 
144009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_LOCK(X)		mtx_lock(&X->is_lock)
145009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_UNLOCK(X)		mtx_unlock(&X->is_lock)
146009ea47eSEdward Tomasz Napierala #define ISCSI_SESSION_LOCK_ASSERT(X)	mtx_assert(&X->is_lock, MA_OWNED)
147c215ad3aSAlexander Motin #define ISCSI_SESSION_LOCK_ASSERT_NOT(X) mtx_assert(&X->is_lock, MA_NOTOWNED)
148009ea47eSEdward Tomasz Napierala 
149009ea47eSEdward Tomasz Napierala static int	iscsi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg,
150009ea47eSEdward Tomasz Napierala 		    int mode, struct thread *td);
151009ea47eSEdward Tomasz Napierala 
152009ea47eSEdward Tomasz Napierala static struct cdevsw iscsi_cdevsw = {
153009ea47eSEdward Tomasz Napierala      .d_version = D_VERSION,
154009ea47eSEdward Tomasz Napierala      .d_ioctl   = iscsi_ioctl,
155009ea47eSEdward Tomasz Napierala      .d_name    = "iscsi",
156009ea47eSEdward Tomasz Napierala };
157009ea47eSEdward Tomasz Napierala 
158009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_queue_locked(struct icl_pdu *request);
159009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_queue(struct icl_pdu *request);
160009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_update_statsn(const struct icl_pdu *response);
161009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_nop_in(struct icl_pdu *response);
162009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_scsi_response(struct icl_pdu *response);
163aa75114cSAlexander Motin static void	iscsi_pdu_handle_task_response(struct icl_pdu *response);
164009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_data_in(struct icl_pdu *response);
165009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_logout_response(struct icl_pdu *response);
166009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_r2t(struct icl_pdu *response);
167009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_async_message(struct icl_pdu *response);
168009ea47eSEdward Tomasz Napierala static void	iscsi_pdu_handle_reject(struct icl_pdu *response);
169009ea47eSEdward Tomasz Napierala static void	iscsi_session_reconnect(struct iscsi_session *is);
170009ea47eSEdward Tomasz Napierala static void	iscsi_session_terminate(struct iscsi_session *is);
171009ea47eSEdward Tomasz Napierala static void	iscsi_action(struct cam_sim *sim, union ccb *ccb);
172009ea47eSEdward Tomasz Napierala static void	iscsi_poll(struct cam_sim *sim);
173009ea47eSEdward Tomasz Napierala static struct iscsi_outstanding	*iscsi_outstanding_find(struct iscsi_session *is,
174009ea47eSEdward Tomasz Napierala 		    uint32_t initiator_task_tag);
175aa75114cSAlexander Motin static struct iscsi_outstanding	*iscsi_outstanding_add(struct iscsi_session *is,
176604c023fSEdward Tomasz Napierala 		    struct icl_pdu *request, union ccb *ccb,
177604c023fSEdward Tomasz Napierala 		    uint32_t *initiator_task_tagp);
178009ea47eSEdward Tomasz Napierala static void	iscsi_outstanding_remove(struct iscsi_session *is,
179009ea47eSEdward Tomasz Napierala 		    struct iscsi_outstanding *io);
180009ea47eSEdward Tomasz Napierala 
181009ea47eSEdward Tomasz Napierala static bool
182009ea47eSEdward Tomasz Napierala iscsi_pdu_prepare(struct icl_pdu *request)
183009ea47eSEdward Tomasz Napierala {
184009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
185009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_command *bhssc;
186009ea47eSEdward Tomasz Napierala 
187009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
188009ea47eSEdward Tomasz Napierala 
189009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
190009ea47eSEdward Tomasz Napierala 
191009ea47eSEdward Tomasz Napierala 	/*
192009ea47eSEdward Tomasz Napierala 	 * We're only using fields common for all the request
193009ea47eSEdward Tomasz Napierala 	 * (initiator -> target) PDUs.
194009ea47eSEdward Tomasz Napierala 	 */
195009ea47eSEdward Tomasz Napierala 	bhssc = (struct iscsi_bhs_scsi_command *)request->ip_bhs;
196009ea47eSEdward Tomasz Napierala 
197009ea47eSEdward Tomasz Napierala 	/*
198009ea47eSEdward Tomasz Napierala 	 * Data-Out PDU does not contain CmdSN.
199009ea47eSEdward Tomasz Napierala 	 */
200009ea47eSEdward Tomasz Napierala 	if (bhssc->bhssc_opcode != ISCSI_BHS_OPCODE_SCSI_DATA_OUT) {
2012124e3b0SAlexander Motin 		if (ISCSI_SNGT(is->is_cmdsn, is->is_maxcmdsn) &&
202009ea47eSEdward Tomasz Napierala 		    (bhssc->bhssc_opcode & ISCSI_BHS_OPCODE_IMMEDIATE) == 0) {
203009ea47eSEdward Tomasz Napierala 			/*
204009ea47eSEdward Tomasz Napierala 			 * Current MaxCmdSN prevents us from sending any more
205009ea47eSEdward Tomasz Napierala 			 * SCSI Command PDUs to the target; postpone the PDU.
206009ea47eSEdward Tomasz Napierala 			 * It will get resent by either iscsi_pdu_queue(),
207009ea47eSEdward Tomasz Napierala 			 * or by maintenance thread.
208009ea47eSEdward Tomasz Napierala 			 */
209009ea47eSEdward Tomasz Napierala #if 0
2102124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is, "postponing send, CmdSN %u, "
2112124e3b0SAlexander Motin 			    "ExpCmdSN %u, MaxCmdSN %u, opcode 0x%x",
2122124e3b0SAlexander Motin 			    is->is_cmdsn, is->is_expcmdsn, is->is_maxcmdsn,
2132124e3b0SAlexander Motin 			    bhssc->bhssc_opcode);
214009ea47eSEdward Tomasz Napierala #endif
215009ea47eSEdward Tomasz Napierala 			return (true);
216009ea47eSEdward Tomasz Napierala 		}
217009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_cmdsn = htonl(is->is_cmdsn);
218009ea47eSEdward Tomasz Napierala 		if ((bhssc->bhssc_opcode & ISCSI_BHS_OPCODE_IMMEDIATE) == 0)
219009ea47eSEdward Tomasz Napierala 			is->is_cmdsn++;
220009ea47eSEdward Tomasz Napierala 	}
221009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_expstatsn = htonl(is->is_statsn + 1);
222009ea47eSEdward Tomasz Napierala 
223009ea47eSEdward Tomasz Napierala 	return (false);
224009ea47eSEdward Tomasz Napierala }
225009ea47eSEdward Tomasz Napierala 
226009ea47eSEdward Tomasz Napierala static void
227009ea47eSEdward Tomasz Napierala iscsi_session_send_postponed(struct iscsi_session *is)
228009ea47eSEdward Tomasz Napierala {
229009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
230009ea47eSEdward Tomasz Napierala 	bool postpone;
231009ea47eSEdward Tomasz Napierala 
232009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
233009ea47eSEdward Tomasz Napierala 
23416c158a5SEdward Tomasz Napierala 	while (!STAILQ_EMPTY(&is->is_postponed)) {
23516c158a5SEdward Tomasz Napierala 		request = STAILQ_FIRST(&is->is_postponed);
236009ea47eSEdward Tomasz Napierala 		postpone = iscsi_pdu_prepare(request);
237009ea47eSEdward Tomasz Napierala 		if (postpone)
238009ea47eSEdward Tomasz Napierala 			break;
23916c158a5SEdward Tomasz Napierala 		STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
240009ea47eSEdward Tomasz Napierala 		icl_pdu_queue(request);
241009ea47eSEdward Tomasz Napierala 	}
242009ea47eSEdward Tomasz Napierala }
243009ea47eSEdward Tomasz Napierala 
244009ea47eSEdward Tomasz Napierala static void
245009ea47eSEdward Tomasz Napierala iscsi_pdu_queue_locked(struct icl_pdu *request)
246009ea47eSEdward Tomasz Napierala {
247009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
248009ea47eSEdward Tomasz Napierala 	bool postpone;
249009ea47eSEdward Tomasz Napierala 
250009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
251009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
252009ea47eSEdward Tomasz Napierala 	iscsi_session_send_postponed(is);
253009ea47eSEdward Tomasz Napierala 	postpone = iscsi_pdu_prepare(request);
254009ea47eSEdward Tomasz Napierala 	if (postpone) {
25516c158a5SEdward Tomasz Napierala 		STAILQ_INSERT_TAIL(&is->is_postponed, request, ip_next);
256009ea47eSEdward Tomasz Napierala 		return;
257009ea47eSEdward Tomasz Napierala 	}
258009ea47eSEdward Tomasz Napierala 	icl_pdu_queue(request);
259009ea47eSEdward Tomasz Napierala }
260009ea47eSEdward Tomasz Napierala 
261009ea47eSEdward Tomasz Napierala static void
262009ea47eSEdward Tomasz Napierala iscsi_pdu_queue(struct icl_pdu *request)
263009ea47eSEdward Tomasz Napierala {
264009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
265009ea47eSEdward Tomasz Napierala 
266009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(request);
267009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
268009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
269009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
270009ea47eSEdward Tomasz Napierala }
271009ea47eSEdward Tomasz Napierala 
272009ea47eSEdward Tomasz Napierala static void
273009ea47eSEdward Tomasz Napierala iscsi_session_logout(struct iscsi_session *is)
274009ea47eSEdward Tomasz Napierala {
275009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
276009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_logout_request *bhslr;
277009ea47eSEdward Tomasz Napierala 
278d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
279009ea47eSEdward Tomasz Napierala 	if (request == NULL)
280009ea47eSEdward Tomasz Napierala 		return;
281009ea47eSEdward Tomasz Napierala 
282009ea47eSEdward Tomasz Napierala 	bhslr = (struct iscsi_bhs_logout_request *)request->ip_bhs;
283009ea47eSEdward Tomasz Napierala 	bhslr->bhslr_opcode = ISCSI_BHS_OPCODE_LOGOUT_REQUEST;
284009ea47eSEdward Tomasz Napierala 	bhslr->bhslr_reason = BHSLR_REASON_CLOSE_SESSION;
285009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
286009ea47eSEdward Tomasz Napierala }
287009ea47eSEdward Tomasz Napierala 
288009ea47eSEdward Tomasz Napierala static void
289aa75114cSAlexander Motin iscsi_session_terminate_task(struct iscsi_session *is,
290aa75114cSAlexander Motin     struct iscsi_outstanding *io, bool requeue)
291aa75114cSAlexander Motin {
292aa75114cSAlexander Motin 
293e204e2cdSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
294e204e2cdSEdward Tomasz Napierala 
295aa75114cSAlexander Motin 	if (io->io_ccb != NULL) {
296aa75114cSAlexander Motin 		io->io_ccb->ccb_h.status &= ~(CAM_SIM_QUEUED | CAM_STATUS_MASK);
297aa75114cSAlexander Motin 		if (requeue)
298aa75114cSAlexander Motin 			io->io_ccb->ccb_h.status |= CAM_REQUEUE_REQ;
299aa75114cSAlexander Motin 		else
300aa75114cSAlexander Motin 			io->io_ccb->ccb_h.status |= CAM_REQ_ABORTED;
301aa75114cSAlexander Motin 		if ((io->io_ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
302aa75114cSAlexander Motin 			io->io_ccb->ccb_h.status |= CAM_DEV_QFRZN;
303aa75114cSAlexander Motin 			xpt_freeze_devq(io->io_ccb->ccb_h.path, 1);
304aa75114cSAlexander Motin 			ISCSI_SESSION_DEBUG(is, "freezing devq");
305aa75114cSAlexander Motin 		}
306aa75114cSAlexander Motin 		xpt_done(io->io_ccb);
307aa75114cSAlexander Motin 	}
308aa75114cSAlexander Motin 	iscsi_outstanding_remove(is, io);
309aa75114cSAlexander Motin }
310aa75114cSAlexander Motin 
311aa75114cSAlexander Motin static void
312009ea47eSEdward Tomasz Napierala iscsi_session_terminate_tasks(struct iscsi_session *is, bool requeue)
313009ea47eSEdward Tomasz Napierala {
314009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io, *tmp;
315009ea47eSEdward Tomasz Napierala 
316009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
317009ea47eSEdward Tomasz Napierala 
318009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH_SAFE(io, &is->is_outstanding, io_next, tmp) {
319aa75114cSAlexander Motin 		iscsi_session_terminate_task(is, io, requeue);
320009ea47eSEdward Tomasz Napierala 	}
321009ea47eSEdward Tomasz Napierala }
322009ea47eSEdward Tomasz Napierala 
323009ea47eSEdward Tomasz Napierala static void
324f1f12e40SEdward Tomasz Napierala iscsi_session_cleanup(struct iscsi_session *is, bool destroy_sim)
325009ea47eSEdward Tomasz Napierala {
326009ea47eSEdward Tomasz Napierala 	struct icl_pdu *pdu;
327009ea47eSEdward Tomasz Napierala 
328f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
329009ea47eSEdward Tomasz Napierala 
330009ea47eSEdward Tomasz Napierala 	/*
331009ea47eSEdward Tomasz Napierala 	 * Don't queue any new PDUs.
332009ea47eSEdward Tomasz Napierala 	 */
333009ea47eSEdward Tomasz Napierala 	if (is->is_sim != NULL && is->is_simq_frozen == false) {
334009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "freezing");
335009ea47eSEdward Tomasz Napierala 		xpt_freeze_simq(is->is_sim, 1);
336009ea47eSEdward Tomasz Napierala 		is->is_simq_frozen = true;
337009ea47eSEdward Tomasz Napierala 	}
338009ea47eSEdward Tomasz Napierala 
339009ea47eSEdward Tomasz Napierala 	/*
340009ea47eSEdward Tomasz Napierala 	 * Remove postponed PDUs.
341009ea47eSEdward Tomasz Napierala 	 */
34216c158a5SEdward Tomasz Napierala 	while (!STAILQ_EMPTY(&is->is_postponed)) {
34316c158a5SEdward Tomasz Napierala 		pdu = STAILQ_FIRST(&is->is_postponed);
34416c158a5SEdward Tomasz Napierala 		STAILQ_REMOVE_HEAD(&is->is_postponed, ip_next);
345009ea47eSEdward Tomasz Napierala 		icl_pdu_free(pdu);
346009ea47eSEdward Tomasz Napierala 	}
347009ea47eSEdward Tomasz Napierala 
348f1f12e40SEdward Tomasz Napierala 	if (destroy_sim == false) {
349009ea47eSEdward Tomasz Napierala 		/*
350009ea47eSEdward Tomasz Napierala 		 * Terminate SCSI tasks, asking CAM to requeue them.
351009ea47eSEdward Tomasz Napierala 		 */
352009ea47eSEdward Tomasz Napierala 		iscsi_session_terminate_tasks(is, true);
353f1f12e40SEdward Tomasz Napierala 		return;
354f1f12e40SEdward Tomasz Napierala 	}
355f1f12e40SEdward Tomasz Napierala 
356f1f12e40SEdward Tomasz Napierala 	iscsi_session_terminate_tasks(is, false);
357f1f12e40SEdward Tomasz Napierala 
358f1f12e40SEdward Tomasz Napierala 	if (is->is_sim == NULL)
359f1f12e40SEdward Tomasz Napierala 		return;
360f1f12e40SEdward Tomasz Napierala 
361f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "deregistering SIM");
362f1f12e40SEdward Tomasz Napierala 	xpt_async(AC_LOST_DEVICE, is->is_path, NULL);
363f1f12e40SEdward Tomasz Napierala 
364f1f12e40SEdward Tomasz Napierala 	if (is->is_simq_frozen) {
365f1f12e40SEdward Tomasz Napierala 		xpt_release_simq(is->is_sim, 1);
366f1f12e40SEdward Tomasz Napierala 		is->is_simq_frozen = false;
367f1f12e40SEdward Tomasz Napierala 	}
368f1f12e40SEdward Tomasz Napierala 
369f1f12e40SEdward Tomasz Napierala 	xpt_free_path(is->is_path);
370f1f12e40SEdward Tomasz Napierala 	is->is_path = NULL;
371f1f12e40SEdward Tomasz Napierala 	xpt_bus_deregister(cam_sim_path(is->is_sim));
372f1f12e40SEdward Tomasz Napierala 	cam_sim_free(is->is_sim, TRUE /*free_devq*/);
373f1f12e40SEdward Tomasz Napierala 	is->is_sim = NULL;
374f1f12e40SEdward Tomasz Napierala 	is->is_devq = NULL;
375f1f12e40SEdward Tomasz Napierala }
376f1f12e40SEdward Tomasz Napierala 
377f1f12e40SEdward Tomasz Napierala static void
378f1f12e40SEdward Tomasz Napierala iscsi_maintenance_thread_reconnect(struct iscsi_session *is)
379f1f12e40SEdward Tomasz Napierala {
380f1f12e40SEdward Tomasz Napierala 
381f1f12e40SEdward Tomasz Napierala 	icl_conn_close(is->is_conn);
382f1f12e40SEdward Tomasz Napierala 
383f1f12e40SEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
384f1f12e40SEdward Tomasz Napierala 
385f1f12e40SEdward Tomasz Napierala 	is->is_connected = false;
386f1f12e40SEdward Tomasz Napierala 	is->is_reconnecting = false;
387f1f12e40SEdward Tomasz Napierala 	is->is_login_phase = false;
388f1f12e40SEdward Tomasz Napierala 
389f1f12e40SEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
390f1f12e40SEdward Tomasz Napierala 	if (is->is_login_pdu != NULL) {
391f1f12e40SEdward Tomasz Napierala 		icl_pdu_free(is->is_login_pdu);
392f1f12e40SEdward Tomasz Napierala 		is->is_login_pdu = NULL;
393f1f12e40SEdward Tomasz Napierala 	}
394f1f12e40SEdward Tomasz Napierala 	cv_signal(&is->is_login_cv);
395f1f12e40SEdward Tomasz Napierala #endif
396f1f12e40SEdward Tomasz Napierala 
397f1f12e40SEdward Tomasz Napierala 	if (fail_on_disconnection) {
398f1f12e40SEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "connection failed, destroying devices");
399f1f12e40SEdward Tomasz Napierala 		iscsi_session_cleanup(is, true);
400f1f12e40SEdward Tomasz Napierala 	} else {
401f1f12e40SEdward Tomasz Napierala 		iscsi_session_cleanup(is, false);
402f1f12e40SEdward Tomasz Napierala 	}
403009ea47eSEdward Tomasz Napierala 
404009ea47eSEdward Tomasz Napierala 	KASSERT(TAILQ_EMPTY(&is->is_outstanding),
405009ea47eSEdward Tomasz Napierala 	    ("destroying session with active tasks"));
40616c158a5SEdward Tomasz Napierala 	KASSERT(STAILQ_EMPTY(&is->is_postponed),
407009ea47eSEdward Tomasz Napierala 	    ("destroying session with postponed PDUs"));
408009ea47eSEdward Tomasz Napierala 
409009ea47eSEdward Tomasz Napierala 	/*
410009ea47eSEdward Tomasz Napierala 	 * Request immediate reconnection from iscsid(8).
411009ea47eSEdward Tomasz Napierala 	 */
412009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "waking up iscsid(8)");
413009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = true;
414009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
415009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
416009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
417009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_softc->sc_cv);
418009ea47eSEdward Tomasz Napierala }
419009ea47eSEdward Tomasz Napierala 
420009ea47eSEdward Tomasz Napierala static void
421009ea47eSEdward Tomasz Napierala iscsi_maintenance_thread_terminate(struct iscsi_session *is)
422009ea47eSEdward Tomasz Napierala {
423009ea47eSEdward Tomasz Napierala 	struct iscsi_softc *sc;
424009ea47eSEdward Tomasz Napierala 
425009ea47eSEdward Tomasz Napierala 	sc = is->is_softc;
426009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
427009ea47eSEdward Tomasz Napierala 
428009ea47eSEdward Tomasz Napierala 	icl_conn_close(is->is_conn);
429674074daSEdward Tomasz Napierala 	callout_drain(&is->is_callout);
430009ea47eSEdward Tomasz Napierala 
431009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
432009ea47eSEdward Tomasz Napierala 
433009ea47eSEdward Tomasz Napierala 	KASSERT(is->is_terminating, ("is_terminating == false"));
434009ea47eSEdward Tomasz Napierala 
435009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
436009ea47eSEdward Tomasz Napierala 	if (is->is_login_pdu != NULL) {
437009ea47eSEdward Tomasz Napierala 		icl_pdu_free(is->is_login_pdu);
438009ea47eSEdward Tomasz Napierala 		is->is_login_pdu = NULL;
439009ea47eSEdward Tomasz Napierala 	}
440009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_login_cv);
441009ea47eSEdward Tomasz Napierala #endif
442009ea47eSEdward Tomasz Napierala 
443f1f12e40SEdward Tomasz Napierala 	iscsi_session_cleanup(is, true);
444009ea47eSEdward Tomasz Napierala 
445009ea47eSEdward Tomasz Napierala 	KASSERT(TAILQ_EMPTY(&is->is_outstanding),
446009ea47eSEdward Tomasz Napierala 	    ("destroying session with active tasks"));
44716c158a5SEdward Tomasz Napierala 	KASSERT(STAILQ_EMPTY(&is->is_postponed),
448009ea47eSEdward Tomasz Napierala 	    ("destroying session with postponed PDUs"));
449009ea47eSEdward Tomasz Napierala 
450009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
451009ea47eSEdward Tomasz Napierala 
452009ea47eSEdward Tomasz Napierala 	icl_conn_free(is->is_conn);
453009ea47eSEdward Tomasz Napierala 	mtx_destroy(&is->is_lock);
454009ea47eSEdward Tomasz Napierala 	cv_destroy(&is->is_maintenance_cv);
455009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
456009ea47eSEdward Tomasz Napierala 	cv_destroy(&is->is_login_cv);
457009ea47eSEdward Tomasz Napierala #endif
458481b36c6SSteven Hartland 	TAILQ_REMOVE(&sc->sc_sessions, is, is_next);
459481b36c6SSteven Hartland 	sx_xunlock(&sc->sc_lock);
460481b36c6SSteven Hartland 
461009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "terminated");
462009ea47eSEdward Tomasz Napierala 	free(is, M_ISCSI);
463009ea47eSEdward Tomasz Napierala 
464009ea47eSEdward Tomasz Napierala 	/*
465009ea47eSEdward Tomasz Napierala 	 * The iscsi_unload() routine might be waiting.
466009ea47eSEdward Tomasz Napierala 	 */
467009ea47eSEdward Tomasz Napierala 	cv_signal(&sc->sc_cv);
468009ea47eSEdward Tomasz Napierala }
469009ea47eSEdward Tomasz Napierala 
470009ea47eSEdward Tomasz Napierala static void
471009ea47eSEdward Tomasz Napierala iscsi_maintenance_thread(void *arg)
472009ea47eSEdward Tomasz Napierala {
473009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
474009ea47eSEdward Tomasz Napierala 
475009ea47eSEdward Tomasz Napierala 	is = arg;
476009ea47eSEdward Tomasz Napierala 
477009ea47eSEdward Tomasz Napierala 	for (;;) {
478009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
479009ea47eSEdward Tomasz Napierala 		if (is->is_reconnecting == false &&
480009ea47eSEdward Tomasz Napierala 		    is->is_terminating == false &&
48116c158a5SEdward Tomasz Napierala 		    STAILQ_EMPTY(&is->is_postponed))
482009ea47eSEdward Tomasz Napierala 			cv_wait(&is->is_maintenance_cv, &is->is_lock);
483009ea47eSEdward Tomasz Napierala 
484481b36c6SSteven Hartland 		/* Terminate supersedes reconnect. */
485009ea47eSEdward Tomasz Napierala 		if (is->is_terminating) {
486009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
487009ea47eSEdward Tomasz Napierala 			iscsi_maintenance_thread_terminate(is);
488009ea47eSEdward Tomasz Napierala 			kthread_exit();
489009ea47eSEdward Tomasz Napierala 			return;
490009ea47eSEdward Tomasz Napierala 		}
491009ea47eSEdward Tomasz Napierala 
492481b36c6SSteven Hartland 		if (is->is_reconnecting) {
493481b36c6SSteven Hartland 			ISCSI_SESSION_UNLOCK(is);
494481b36c6SSteven Hartland 			iscsi_maintenance_thread_reconnect(is);
495481b36c6SSteven Hartland 			continue;
496481b36c6SSteven Hartland 		}
497481b36c6SSteven Hartland 
498009ea47eSEdward Tomasz Napierala 		iscsi_session_send_postponed(is);
499009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
500009ea47eSEdward Tomasz Napierala 	}
501009ea47eSEdward Tomasz Napierala }
502009ea47eSEdward Tomasz Napierala 
503009ea47eSEdward Tomasz Napierala static void
504009ea47eSEdward Tomasz Napierala iscsi_session_reconnect(struct iscsi_session *is)
505009ea47eSEdward Tomasz Napierala {
506009ea47eSEdward Tomasz Napierala 
507009ea47eSEdward Tomasz Napierala 	/*
508009ea47eSEdward Tomasz Napierala 	 * XXX: We can't use locking here, because
509009ea47eSEdward Tomasz Napierala 	 * 	it's being called from various contexts.
510009ea47eSEdward Tomasz Napierala 	 * 	Hope it doesn't break anything.
511009ea47eSEdward Tomasz Napierala 	 */
512009ea47eSEdward Tomasz Napierala 	if (is->is_reconnecting)
513009ea47eSEdward Tomasz Napierala 		return;
514009ea47eSEdward Tomasz Napierala 
515009ea47eSEdward Tomasz Napierala 	is->is_reconnecting = true;
516009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_maintenance_cv);
517009ea47eSEdward Tomasz Napierala }
518009ea47eSEdward Tomasz Napierala 
519009ea47eSEdward Tomasz Napierala static void
520009ea47eSEdward Tomasz Napierala iscsi_session_terminate(struct iscsi_session *is)
521009ea47eSEdward Tomasz Napierala {
522674074daSEdward Tomasz Napierala 
523009ea47eSEdward Tomasz Napierala 	if (is->is_terminating)
524009ea47eSEdward Tomasz Napierala 		return;
525009ea47eSEdward Tomasz Napierala 
526009ea47eSEdward Tomasz Napierala 	is->is_terminating = true;
527009ea47eSEdward Tomasz Napierala 
528009ea47eSEdward Tomasz Napierala #if 0
529009ea47eSEdward Tomasz Napierala 	iscsi_session_logout(is);
530009ea47eSEdward Tomasz Napierala #endif
531009ea47eSEdward Tomasz Napierala 	cv_signal(&is->is_maintenance_cv);
532009ea47eSEdward Tomasz Napierala }
533009ea47eSEdward Tomasz Napierala 
534009ea47eSEdward Tomasz Napierala static void
535009ea47eSEdward Tomasz Napierala iscsi_callout(void *context)
536009ea47eSEdward Tomasz Napierala {
537009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
538009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_out *bhsno;
539009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
540009ea47eSEdward Tomasz Napierala 	bool reconnect_needed = false;
541009ea47eSEdward Tomasz Napierala 
542009ea47eSEdward Tomasz Napierala 	is = context;
543009ea47eSEdward Tomasz Napierala 
544674074daSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
545674074daSEdward Tomasz Napierala 	if (is->is_terminating) {
546674074daSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
547009ea47eSEdward Tomasz Napierala 		return;
548674074daSEdward Tomasz Napierala 	}
549009ea47eSEdward Tomasz Napierala 
550009ea47eSEdward Tomasz Napierala 	callout_schedule(&is->is_callout, 1 * hz);
551009ea47eSEdward Tomasz Napierala 
552009ea47eSEdward Tomasz Napierala 	is->is_timeout++;
553009ea47eSEdward Tomasz Napierala 
554009ea47eSEdward Tomasz Napierala 	if (is->is_waiting_for_iscsid) {
5552c5b89e5SEdward Tomasz Napierala 		if (iscsid_timeout > 0 && is->is_timeout > iscsid_timeout) {
556009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "timed out waiting for iscsid(8) "
557009ea47eSEdward Tomasz Napierala 			    "for %d seconds; reconnecting",
558009ea47eSEdward Tomasz Napierala 			    is->is_timeout);
559009ea47eSEdward Tomasz Napierala 			reconnect_needed = true;
560009ea47eSEdward Tomasz Napierala 		}
561009ea47eSEdward Tomasz Napierala 		goto out;
562009ea47eSEdward Tomasz Napierala 	}
563009ea47eSEdward Tomasz Napierala 
564009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
5652c5b89e5SEdward Tomasz Napierala 		if (login_timeout > 0 && is->is_timeout > login_timeout) {
566009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "login timed out after %d seconds; "
567009ea47eSEdward Tomasz Napierala 			    "reconnecting", is->is_timeout);
568009ea47eSEdward Tomasz Napierala 			reconnect_needed = true;
569009ea47eSEdward Tomasz Napierala 		}
570009ea47eSEdward Tomasz Napierala 		goto out;
571009ea47eSEdward Tomasz Napierala 	}
572009ea47eSEdward Tomasz Napierala 
5732c5b89e5SEdward Tomasz Napierala 	if (ping_timeout <= 0) {
5742c5b89e5SEdward Tomasz Napierala 		/*
5752c5b89e5SEdward Tomasz Napierala 		 * Pings are disabled.  Don't send NOP-Out in this case.
5762c5b89e5SEdward Tomasz Napierala 		 * Reset the timeout, to avoid triggering reconnection,
5772c5b89e5SEdward Tomasz Napierala 		 * should the user decide to reenable them.
5782c5b89e5SEdward Tomasz Napierala 		 */
5792c5b89e5SEdward Tomasz Napierala 		is->is_timeout = 0;
5802c5b89e5SEdward Tomasz Napierala 		goto out;
5812c5b89e5SEdward Tomasz Napierala 	}
5822c5b89e5SEdward Tomasz Napierala 
583009ea47eSEdward Tomasz Napierala 	if (is->is_timeout >= ping_timeout) {
584009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "no ping reply (NOP-In) after %d seconds; "
585009ea47eSEdward Tomasz Napierala 		    "reconnecting", ping_timeout);
586009ea47eSEdward Tomasz Napierala 		reconnect_needed = true;
587009ea47eSEdward Tomasz Napierala 		goto out;
588009ea47eSEdward Tomasz Napierala 	}
589009ea47eSEdward Tomasz Napierala 
590009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
591009ea47eSEdward Tomasz Napierala 
592009ea47eSEdward Tomasz Napierala 	/*
593009ea47eSEdward Tomasz Napierala 	 * If the ping was reset less than one second ago - which means
594009ea47eSEdward Tomasz Napierala 	 * that we've received some PDU during the last second - assume
595009ea47eSEdward Tomasz Napierala 	 * the traffic flows correctly and don't bother sending a NOP-Out.
596009ea47eSEdward Tomasz Napierala 	 *
597009ea47eSEdward Tomasz Napierala 	 * (It's 2 - one for one second, and one for incrementing is_timeout
598009ea47eSEdward Tomasz Napierala 	 * earlier in this routine.)
599009ea47eSEdward Tomasz Napierala 	 */
600009ea47eSEdward Tomasz Napierala 	if (is->is_timeout < 2)
601009ea47eSEdward Tomasz Napierala 		return;
602009ea47eSEdward Tomasz Napierala 
603d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
60446aaea89SEdward Tomasz Napierala 	if (request == NULL) {
60546aaea89SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate PDU");
60646aaea89SEdward Tomasz Napierala 		return;
60746aaea89SEdward Tomasz Napierala 	}
608009ea47eSEdward Tomasz Napierala 	bhsno = (struct iscsi_bhs_nop_out *)request->ip_bhs;
609009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_opcode = ISCSI_BHS_OPCODE_NOP_OUT |
610009ea47eSEdward Tomasz Napierala 	    ISCSI_BHS_OPCODE_IMMEDIATE;
611009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_flags = 0x80;
612009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_target_transfer_tag = 0xffffffff;
613009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue(request);
614009ea47eSEdward Tomasz Napierala 	return;
615009ea47eSEdward Tomasz Napierala 
616009ea47eSEdward Tomasz Napierala out:
617481b36c6SSteven Hartland 	if (is->is_terminating) {
618481b36c6SSteven Hartland 		ISCSI_SESSION_UNLOCK(is);
619481b36c6SSteven Hartland 		return;
620481b36c6SSteven Hartland 	}
621481b36c6SSteven Hartland 
622009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
623009ea47eSEdward Tomasz Napierala 
624009ea47eSEdward Tomasz Napierala 	if (reconnect_needed)
625009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
626009ea47eSEdward Tomasz Napierala }
627009ea47eSEdward Tomasz Napierala 
628009ea47eSEdward Tomasz Napierala static void
629009ea47eSEdward Tomasz Napierala iscsi_pdu_update_statsn(const struct icl_pdu *response)
630009ea47eSEdward Tomasz Napierala {
631009ea47eSEdward Tomasz Napierala 	const struct iscsi_bhs_data_in *bhsdi;
632009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
6332124e3b0SAlexander Motin 	uint32_t expcmdsn, maxcmdsn, statsn;
634009ea47eSEdward Tomasz Napierala 
635009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
636009ea47eSEdward Tomasz Napierala 
637009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
638009ea47eSEdward Tomasz Napierala 
639009ea47eSEdward Tomasz Napierala 	/*
640009ea47eSEdward Tomasz Napierala 	 * We're only using fields common for all the response
641009ea47eSEdward Tomasz Napierala 	 * (target -> initiator) PDUs.
642009ea47eSEdward Tomasz Napierala 	 */
643009ea47eSEdward Tomasz Napierala 	bhsdi = (const struct iscsi_bhs_data_in *)response->ip_bhs;
644009ea47eSEdward Tomasz Napierala 	/*
645009ea47eSEdward Tomasz Napierala 	 * Ok, I lied.  In case of Data-In, "The fields StatSN, Status,
646009ea47eSEdward Tomasz Napierala 	 * and Residual Count only have meaningful content if the S bit
647009ea47eSEdward Tomasz Napierala 	 * is set to 1", so we also need to check the bit specific for
648009ea47eSEdward Tomasz Napierala 	 * Data-In PDU.
649009ea47eSEdward Tomasz Napierala 	 */
650009ea47eSEdward Tomasz Napierala 	if (bhsdi->bhsdi_opcode != ISCSI_BHS_OPCODE_SCSI_DATA_IN ||
651009ea47eSEdward Tomasz Napierala 	    (bhsdi->bhsdi_flags & BHSDI_FLAGS_S) != 0) {
6522124e3b0SAlexander Motin 		statsn = ntohl(bhsdi->bhsdi_statsn);
6532124e3b0SAlexander Motin 		if (statsn != is->is_statsn && statsn != (is->is_statsn + 1)) {
6542124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
6552124e3b0SAlexander Motin 			ISCSI_SESSION_WARN(is, "PDU 0x%x StatSN %u != "
6562124e3b0SAlexander Motin 			    "session ExpStatSN %u (or + 1); reconnecting",
6572124e3b0SAlexander Motin 			    bhsdi->bhsdi_opcode, statsn, is->is_statsn);
6582124e3b0SAlexander Motin 			iscsi_session_reconnect(is);
659009ea47eSEdward Tomasz Napierala 		}
6602124e3b0SAlexander Motin 		if (ISCSI_SNGT(statsn, is->is_statsn))
6612124e3b0SAlexander Motin 			is->is_statsn = statsn;
662009ea47eSEdward Tomasz Napierala 	}
663009ea47eSEdward Tomasz Napierala 
664009ea47eSEdward Tomasz Napierala 	expcmdsn = ntohl(bhsdi->bhsdi_expcmdsn);
665009ea47eSEdward Tomasz Napierala 	maxcmdsn = ntohl(bhsdi->bhsdi_maxcmdsn);
666009ea47eSEdward Tomasz Napierala 
6672124e3b0SAlexander Motin 	if (ISCSI_SNLT(maxcmdsn + 1, expcmdsn)) {
6682124e3b0SAlexander Motin 		ISCSI_SESSION_DEBUG(is,
6692124e3b0SAlexander Motin 		    "PDU MaxCmdSN %u + 1 < PDU ExpCmdSN %u; ignoring",
670009ea47eSEdward Tomasz Napierala 		    maxcmdsn, expcmdsn);
671009ea47eSEdward Tomasz Napierala 	} else {
6722124e3b0SAlexander Motin 		if (ISCSI_SNGT(maxcmdsn, is->is_maxcmdsn)) {
673009ea47eSEdward Tomasz Napierala 			is->is_maxcmdsn = maxcmdsn;
674009ea47eSEdward Tomasz Napierala 
675009ea47eSEdward Tomasz Napierala 			/*
676009ea47eSEdward Tomasz Napierala 			 * Command window increased; kick the maintanance thread
677009ea47eSEdward Tomasz Napierala 			 * to send out postponed commands.
678009ea47eSEdward Tomasz Napierala 			 */
67916c158a5SEdward Tomasz Napierala 			if (!STAILQ_EMPTY(&is->is_postponed))
680009ea47eSEdward Tomasz Napierala 				cv_signal(&is->is_maintenance_cv);
6812124e3b0SAlexander Motin 		} else if (ISCSI_SNLT(maxcmdsn, is->is_maxcmdsn)) {
6822124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
6832124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is,
6842124e3b0SAlexander Motin 			    "PDU MaxCmdSN %u < session MaxCmdSN %u; ignoring",
685009ea47eSEdward Tomasz Napierala 			    maxcmdsn, is->is_maxcmdsn);
686009ea47eSEdward Tomasz Napierala 		}
687009ea47eSEdward Tomasz Napierala 
6882124e3b0SAlexander Motin 		if (ISCSI_SNGT(expcmdsn, is->is_expcmdsn)) {
689009ea47eSEdward Tomasz Napierala 			is->is_expcmdsn = expcmdsn;
6902124e3b0SAlexander Motin 		} else if (ISCSI_SNLT(expcmdsn, is->is_expcmdsn)) {
6912124e3b0SAlexander Motin 			/* XXX: This is normal situation for MCS */
6922124e3b0SAlexander Motin 			ISCSI_SESSION_DEBUG(is,
6932124e3b0SAlexander Motin 			    "PDU ExpCmdSN %u < session ExpCmdSN %u; ignoring",
694009ea47eSEdward Tomasz Napierala 			    expcmdsn, is->is_expcmdsn);
695009ea47eSEdward Tomasz Napierala 		}
696009ea47eSEdward Tomasz Napierala 	}
697009ea47eSEdward Tomasz Napierala 
698009ea47eSEdward Tomasz Napierala 	/*
699009ea47eSEdward Tomasz Napierala 	 * Every incoming PDU - not just NOP-In - resets the ping timer.
700009ea47eSEdward Tomasz Napierala 	 * The purpose of the timeout is to reset the connection when it stalls;
701009ea47eSEdward Tomasz Napierala 	 * we don't want this to happen when NOP-In or NOP-Out ends up delayed
702009ea47eSEdward Tomasz Napierala 	 * in some queue.
703009ea47eSEdward Tomasz Napierala 	 */
704009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
705009ea47eSEdward Tomasz Napierala }
706009ea47eSEdward Tomasz Napierala 
707009ea47eSEdward Tomasz Napierala static void
708009ea47eSEdward Tomasz Napierala iscsi_receive_callback(struct icl_pdu *response)
709009ea47eSEdward Tomasz Napierala {
710009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
711009ea47eSEdward Tomasz Napierala 
712009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
713009ea47eSEdward Tomasz Napierala 
714009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
715009ea47eSEdward Tomasz Napierala 
716009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
717009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
718009ea47eSEdward Tomasz Napierala 		if (is->is_login_pdu == NULL)
719009ea47eSEdward Tomasz Napierala 			is->is_login_pdu = response;
720009ea47eSEdward Tomasz Napierala 		else
721009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
722009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
723009ea47eSEdward Tomasz Napierala 		cv_signal(&is->is_login_cv);
724009ea47eSEdward Tomasz Napierala 		return;
725009ea47eSEdward Tomasz Napierala 	}
726009ea47eSEdward Tomasz Napierala #endif
727009ea47eSEdward Tomasz Napierala 
728009ea47eSEdward Tomasz Napierala 	iscsi_pdu_update_statsn(response);
729009ea47eSEdward Tomasz Napierala 
730009ea47eSEdward Tomasz Napierala 	/*
731009ea47eSEdward Tomasz Napierala 	 * The handling routine is responsible for freeing the PDU
732009ea47eSEdward Tomasz Napierala 	 * when it's no longer needed.
733009ea47eSEdward Tomasz Napierala 	 */
734009ea47eSEdward Tomasz Napierala 	switch (response->ip_bhs->bhs_opcode) {
735009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_NOP_IN:
736009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_nop_in(response);
737c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
738009ea47eSEdward Tomasz Napierala 		break;
739009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_SCSI_RESPONSE:
740009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_scsi_response(response);
741c215ad3aSAlexander Motin 		/* Session lock dropped inside. */
742c215ad3aSAlexander Motin 		ISCSI_SESSION_LOCK_ASSERT_NOT(is);
743009ea47eSEdward Tomasz Napierala 		break;
744aa75114cSAlexander Motin 	case ISCSI_BHS_OPCODE_TASK_RESPONSE:
745aa75114cSAlexander Motin 		iscsi_pdu_handle_task_response(response);
746c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
747aa75114cSAlexander Motin 		break;
748009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_SCSI_DATA_IN:
749009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_data_in(response);
750c215ad3aSAlexander Motin 		/* Session lock dropped inside. */
751c215ad3aSAlexander Motin 		ISCSI_SESSION_LOCK_ASSERT_NOT(is);
752009ea47eSEdward Tomasz Napierala 		break;
753009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_LOGOUT_RESPONSE:
754009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_logout_response(response);
755c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
756009ea47eSEdward Tomasz Napierala 		break;
757009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_R2T:
758009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_r2t(response);
759c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
760009ea47eSEdward Tomasz Napierala 		break;
761009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_ASYNC_MESSAGE:
762009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_async_message(response);
763c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
764009ea47eSEdward Tomasz Napierala 		break;
765009ea47eSEdward Tomasz Napierala 	case ISCSI_BHS_OPCODE_REJECT:
766009ea47eSEdward Tomasz Napierala 		iscsi_pdu_handle_reject(response);
767c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
768009ea47eSEdward Tomasz Napierala 		break;
769009ea47eSEdward Tomasz Napierala 	default:
770009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "received PDU with unsupported "
771009ea47eSEdward Tomasz Napierala 		    "opcode 0x%x; reconnecting",
772009ea47eSEdward Tomasz Napierala 		    response->ip_bhs->bhs_opcode);
773009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
774c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
775009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
776009ea47eSEdward Tomasz Napierala 	}
777009ea47eSEdward Tomasz Napierala }
778009ea47eSEdward Tomasz Napierala 
779009ea47eSEdward Tomasz Napierala static void
780009ea47eSEdward Tomasz Napierala iscsi_error_callback(struct icl_conn *ic)
781009ea47eSEdward Tomasz Napierala {
782009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
783009ea47eSEdward Tomasz Napierala 
784009ea47eSEdward Tomasz Napierala 	is = CONN_SESSION(ic);
785009ea47eSEdward Tomasz Napierala 
786009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_WARN(is, "connection error; reconnecting");
787009ea47eSEdward Tomasz Napierala 	iscsi_session_reconnect(is);
788009ea47eSEdward Tomasz Napierala }
789009ea47eSEdward Tomasz Napierala 
790009ea47eSEdward Tomasz Napierala static void
791009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_nop_in(struct icl_pdu *response)
792009ea47eSEdward Tomasz Napierala {
7931008ac5eSEdward Tomasz Napierala 	struct iscsi_session *is;
794009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_out *bhsno;
795009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_nop_in *bhsni;
796009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
7971008ac5eSEdward Tomasz Napierala 	void *data = NULL;
7981008ac5eSEdward Tomasz Napierala 	size_t datasize;
7991008ac5eSEdward Tomasz Napierala 	int error;
800009ea47eSEdward Tomasz Napierala 
8011008ac5eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
802009ea47eSEdward Tomasz Napierala 	bhsni = (struct iscsi_bhs_nop_in *)response->ip_bhs;
803009ea47eSEdward Tomasz Napierala 
804009ea47eSEdward Tomasz Napierala 	if (bhsni->bhsni_target_transfer_tag == 0xffffffff) {
805009ea47eSEdward Tomasz Napierala 		/*
806009ea47eSEdward Tomasz Napierala 		 * Nothing to do; iscsi_pdu_update_statsn() already
807009ea47eSEdward Tomasz Napierala 		 * zeroed the timeout.
808009ea47eSEdward Tomasz Napierala 		 */
809009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
810009ea47eSEdward Tomasz Napierala 		return;
811009ea47eSEdward Tomasz Napierala 	}
812009ea47eSEdward Tomasz Napierala 
8131008ac5eSEdward Tomasz Napierala 	datasize = icl_pdu_data_segment_length(response);
8141008ac5eSEdward Tomasz Napierala 	if (datasize > 0) {
8151008ac5eSEdward Tomasz Napierala 		data = malloc(datasize, M_ISCSI, M_NOWAIT | M_ZERO);
8161008ac5eSEdward Tomasz Napierala 		if (data == NULL) {
8171008ac5eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8181008ac5eSEdward Tomasz Napierala 			    "reconnecting");
8191008ac5eSEdward Tomasz Napierala 			icl_pdu_free(response);
8201008ac5eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
8211008ac5eSEdward Tomasz Napierala 			return;
8221008ac5eSEdward Tomasz Napierala 		}
8231008ac5eSEdward Tomasz Napierala 		icl_pdu_get_data(response, 0, data, datasize);
8241008ac5eSEdward Tomasz Napierala 	}
8251008ac5eSEdward Tomasz Napierala 
826d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(response->ip_conn, M_NOWAIT);
827009ea47eSEdward Tomasz Napierala 	if (request == NULL) {
8281008ac5eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8291008ac5eSEdward Tomasz Napierala 		    "reconnecting");
8301008ac5eSEdward Tomasz Napierala 		free(data, M_ISCSI);
831009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
8321008ac5eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
833009ea47eSEdward Tomasz Napierala 		return;
834009ea47eSEdward Tomasz Napierala 	}
835009ea47eSEdward Tomasz Napierala 	bhsno = (struct iscsi_bhs_nop_out *)request->ip_bhs;
836009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_opcode = ISCSI_BHS_OPCODE_NOP_OUT |
837009ea47eSEdward Tomasz Napierala 	    ISCSI_BHS_OPCODE_IMMEDIATE;
838009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_flags = 0x80;
8391008ac5eSEdward Tomasz Napierala 	bhsno->bhsno_initiator_task_tag = 0xffffffff;
840009ea47eSEdward Tomasz Napierala 	bhsno->bhsno_target_transfer_tag = bhsni->bhsni_target_transfer_tag;
8411008ac5eSEdward Tomasz Napierala 	if (datasize > 0) {
8421008ac5eSEdward Tomasz Napierala 		error = icl_pdu_append_data(request, data, datasize, M_NOWAIT);
8431008ac5eSEdward Tomasz Napierala 		if (error != 0) {
8441008ac5eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
8451008ac5eSEdward Tomasz Napierala 			    "reconnecting");
8461008ac5eSEdward Tomasz Napierala 			free(data, M_ISCSI);
8471008ac5eSEdward Tomasz Napierala 			icl_pdu_free(request);
8481008ac5eSEdward Tomasz Napierala 			icl_pdu_free(response);
8491008ac5eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
8501008ac5eSEdward Tomasz Napierala 			return;
8511008ac5eSEdward Tomasz Napierala 		}
8521008ac5eSEdward Tomasz Napierala 		free(data, M_ISCSI);
8531008ac5eSEdward Tomasz Napierala 	}
854009ea47eSEdward Tomasz Napierala 
855009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
856009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
857009ea47eSEdward Tomasz Napierala }
858009ea47eSEdward Tomasz Napierala 
859009ea47eSEdward Tomasz Napierala static void
860009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_scsi_response(struct icl_pdu *response)
861009ea47eSEdward Tomasz Napierala {
862009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_response *bhssr;
863009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
864009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
86573e2e95dSAlexander Motin 	union ccb *ccb;
866009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
86773e2e95dSAlexander Motin 	size_t data_segment_len, received;
868009ea47eSEdward Tomasz Napierala 	uint16_t sense_len;
869009ea47eSEdward Tomasz Napierala 
870009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
871009ea47eSEdward Tomasz Napierala 
872009ea47eSEdward Tomasz Napierala 	bhssr = (struct iscsi_bhs_scsi_response *)response->ip_bhs;
873009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhssr->bhssr_initiator_task_tag);
874aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
875009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhssr->bhssr_initiator_task_tag);
876009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
877009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
878c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
879009ea47eSEdward Tomasz Napierala 		return;
880009ea47eSEdward Tomasz Napierala 	}
881009ea47eSEdward Tomasz Napierala 
88273e2e95dSAlexander Motin 	ccb = io->io_ccb;
88373e2e95dSAlexander Motin 	received = io->io_received;
884c215ad3aSAlexander Motin 	iscsi_outstanding_remove(is, io);
885c215ad3aSAlexander Motin 	ISCSI_SESSION_UNLOCK(is);
886c215ad3aSAlexander Motin 
887009ea47eSEdward Tomasz Napierala 	if (bhssr->bhssr_response != BHSSR_RESPONSE_COMMAND_COMPLETED) {
888009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "service response 0x%x", bhssr->bhssr_response);
88973e2e95dSAlexander Motin  		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
89073e2e95dSAlexander Motin  			xpt_freeze_devq(ccb->ccb_h.path, 1);
891009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
892009ea47eSEdward Tomasz Napierala 		}
89373e2e95dSAlexander Motin  		ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
894009ea47eSEdward Tomasz Napierala 	} else if (bhssr->bhssr_status == 0) {
89573e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
896009ea47eSEdward Tomasz Napierala 	} else {
89773e2e95dSAlexander Motin  		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
89873e2e95dSAlexander Motin  			xpt_freeze_devq(ccb->ccb_h.path, 1);
899009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
900009ea47eSEdward Tomasz Napierala 		}
90173e2e95dSAlexander Motin  		ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | CAM_DEV_QFRZN;
90273e2e95dSAlexander Motin 		ccb->csio.scsi_status = bhssr->bhssr_status;
903009ea47eSEdward Tomasz Napierala 	}
904009ea47eSEdward Tomasz Napierala 
90573e2e95dSAlexander Motin 	csio = &ccb->csio;
906009ea47eSEdward Tomasz Napierala 	data_segment_len = icl_pdu_data_segment_length(response);
907009ea47eSEdward Tomasz Napierala 	if (data_segment_len > 0) {
908009ea47eSEdward Tomasz Napierala 		if (data_segment_len < sizeof(sense_len)) {
909009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "truncated data segment (%zd bytes)",
910009ea47eSEdward Tomasz Napierala 			    data_segment_len);
91173e2e95dSAlexander Motin 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
91273e2e95dSAlexander Motin 				xpt_freeze_devq(ccb->ccb_h.path, 1);
913009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
914009ea47eSEdward Tomasz Napierala 			}
91573e2e95dSAlexander Motin 			ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
916009ea47eSEdward Tomasz Napierala 			goto out;
917009ea47eSEdward Tomasz Napierala 		}
918009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(response, 0, &sense_len, sizeof(sense_len));
919009ea47eSEdward Tomasz Napierala 		sense_len = ntohs(sense_len);
920009ea47eSEdward Tomasz Napierala #if 0
921009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "sense_len %d, data len %zd",
922009ea47eSEdward Tomasz Napierala 		    sense_len, data_segment_len);
923009ea47eSEdward Tomasz Napierala #endif
924009ea47eSEdward Tomasz Napierala 		if (sizeof(sense_len) + sense_len > data_segment_len) {
925009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "truncated data segment "
926009ea47eSEdward Tomasz Napierala 			    "(%zd bytes, should be %zd)",
927009ea47eSEdward Tomasz Napierala 			    data_segment_len, sizeof(sense_len) + sense_len);
92873e2e95dSAlexander Motin 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
92973e2e95dSAlexander Motin 				xpt_freeze_devq(ccb->ccb_h.path, 1);
930009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
931009ea47eSEdward Tomasz Napierala 			}
93273e2e95dSAlexander Motin 			ccb->ccb_h.status = CAM_REQ_CMP_ERR | CAM_DEV_QFRZN;
933009ea47eSEdward Tomasz Napierala 			goto out;
934009ea47eSEdward Tomasz Napierala 		} else if (sizeof(sense_len) + sense_len < data_segment_len)
935009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "oversize data segment "
936009ea47eSEdward Tomasz Napierala 			    "(%zd bytes, should be %zd)",
937009ea47eSEdward Tomasz Napierala 			    data_segment_len, sizeof(sense_len) + sense_len);
938009ea47eSEdward Tomasz Napierala 		if (sense_len > csio->sense_len) {
939009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "truncating sense from %d to %d",
940009ea47eSEdward Tomasz Napierala 			    sense_len, csio->sense_len);
941009ea47eSEdward Tomasz Napierala 			sense_len = csio->sense_len;
942009ea47eSEdward Tomasz Napierala 		}
943009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(response, sizeof(sense_len), &csio->sense_data, sense_len);
944009ea47eSEdward Tomasz Napierala 		csio->sense_resid = csio->sense_len - sense_len;
94573e2e95dSAlexander Motin 		ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
946009ea47eSEdward Tomasz Napierala 	}
947009ea47eSEdward Tomasz Napierala 
948009ea47eSEdward Tomasz Napierala out:
949009ea47eSEdward Tomasz Napierala 	if (bhssr->bhssr_flags & BHSSR_FLAGS_RESIDUAL_UNDERFLOW)
950009ea47eSEdward Tomasz Napierala 		csio->resid = ntohl(bhssr->bhssr_residual_count);
951009ea47eSEdward Tomasz Napierala 
952009ea47eSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
95373e2e95dSAlexander Motin 		KASSERT(received <= csio->dxfer_len,
95473e2e95dSAlexander Motin 		    ("received > csio->dxfer_len"));
95573e2e95dSAlexander Motin 		if (received < csio->dxfer_len) {
95673e2e95dSAlexander Motin 			if (csio->resid != csio->dxfer_len - received) {
957009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_WARN(is, "underflow mismatch: "
958009ea47eSEdward Tomasz Napierala 				    "target indicates %d, we calculated %zd",
95973e2e95dSAlexander Motin 				    csio->resid, csio->dxfer_len - received);
960009ea47eSEdward Tomasz Napierala 			}
96173e2e95dSAlexander Motin 			csio->resid = csio->dxfer_len - received;
962009ea47eSEdward Tomasz Napierala 		}
963009ea47eSEdward Tomasz Napierala 	}
964009ea47eSEdward Tomasz Napierala 
96573e2e95dSAlexander Motin 	xpt_done(ccb);
966009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
967009ea47eSEdward Tomasz Napierala }
968009ea47eSEdward Tomasz Napierala 
969009ea47eSEdward Tomasz Napierala static void
970aa75114cSAlexander Motin iscsi_pdu_handle_task_response(struct icl_pdu *response)
971aa75114cSAlexander Motin {
972aa75114cSAlexander Motin 	struct iscsi_bhs_task_management_response *bhstmr;
973aa75114cSAlexander Motin 	struct iscsi_outstanding *io, *aio;
974aa75114cSAlexander Motin 	struct iscsi_session *is;
975aa75114cSAlexander Motin 
976aa75114cSAlexander Motin 	is = PDU_SESSION(response);
977aa75114cSAlexander Motin 
978aa75114cSAlexander Motin 	bhstmr = (struct iscsi_bhs_task_management_response *)response->ip_bhs;
979aa75114cSAlexander Motin 	io = iscsi_outstanding_find(is, bhstmr->bhstmr_initiator_task_tag);
980aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb != NULL) {
981aa75114cSAlexander Motin 		ISCSI_SESSION_WARN(is, "bad itt 0x%x",
982aa75114cSAlexander Motin 		    bhstmr->bhstmr_initiator_task_tag);
983aa75114cSAlexander Motin 		icl_pdu_free(response);
984aa75114cSAlexander Motin 		iscsi_session_reconnect(is);
985aa75114cSAlexander Motin 		return;
986aa75114cSAlexander Motin 	}
987aa75114cSAlexander Motin 
988aa75114cSAlexander Motin 	if (bhstmr->bhstmr_response != BHSTMR_RESPONSE_FUNCTION_COMPLETE) {
989aa75114cSAlexander Motin 		ISCSI_SESSION_WARN(is, "task response 0x%x",
990aa75114cSAlexander Motin 		    bhstmr->bhstmr_response);
991aa75114cSAlexander Motin 	} else {
992aa75114cSAlexander Motin 		aio = iscsi_outstanding_find(is, io->io_datasn);
993aa75114cSAlexander Motin 		if (aio != NULL && aio->io_ccb != NULL)
994aa75114cSAlexander Motin 			iscsi_session_terminate_task(is, aio, false);
995aa75114cSAlexander Motin 	}
996aa75114cSAlexander Motin 
997aa75114cSAlexander Motin 	iscsi_outstanding_remove(is, io);
998aa75114cSAlexander Motin 	icl_pdu_free(response);
999aa75114cSAlexander Motin }
1000aa75114cSAlexander Motin 
1001aa75114cSAlexander Motin static void
1002009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_data_in(struct icl_pdu *response)
1003009ea47eSEdward Tomasz Napierala {
1004009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_data_in *bhsdi;
1005009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
1006009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
100773e2e95dSAlexander Motin 	union ccb *ccb;
1008009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
100973e2e95dSAlexander Motin 	size_t data_segment_len, received, oreceived;
1010009ea47eSEdward Tomasz Napierala 
1011009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1012009ea47eSEdward Tomasz Napierala 	bhsdi = (struct iscsi_bhs_data_in *)response->ip_bhs;
1013009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhsdi->bhsdi_initiator_task_tag);
1014aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
1015009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x", bhsdi->bhsdi_initiator_task_tag);
1016009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1017009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1018c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1019009ea47eSEdward Tomasz Napierala 		return;
1020009ea47eSEdward Tomasz Napierala 	}
1021009ea47eSEdward Tomasz Napierala 
1022009ea47eSEdward Tomasz Napierala 	data_segment_len = icl_pdu_data_segment_length(response);
1023009ea47eSEdward Tomasz Napierala 	if (data_segment_len == 0) {
1024009ea47eSEdward Tomasz Napierala 		/*
1025009ea47eSEdward Tomasz Napierala 		 * "The sending of 0 length data segments should be avoided,
1026009ea47eSEdward Tomasz Napierala 		 * but initiators and targets MUST be able to properly receive
1027009ea47eSEdward Tomasz Napierala 		 * 0 length data segments."
1028009ea47eSEdward Tomasz Napierala 		 */
1029c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1030009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1031009ea47eSEdward Tomasz Napierala 		return;
1032009ea47eSEdward Tomasz Napierala 	}
1033009ea47eSEdward Tomasz Napierala 
1034009ea47eSEdward Tomasz Napierala 	/*
1035009ea47eSEdward Tomasz Napierala 	 * We need to track this for security reasons - without it, malicious target
1036009ea47eSEdward Tomasz Napierala 	 * could respond to SCSI READ without sending Data-In PDUs, which would result
1037009ea47eSEdward Tomasz Napierala 	 * in read operation on the initiator side returning random kernel data.
1038009ea47eSEdward Tomasz Napierala 	 */
1039009ea47eSEdward Tomasz Napierala 	if (ntohl(bhsdi->bhsdi_buffer_offset) != io->io_received) {
1040009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "data out of order; expected offset %zd, got %zd",
1041009ea47eSEdward Tomasz Napierala 		    io->io_received, (size_t)ntohl(bhsdi->bhsdi_buffer_offset));
1042009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1043009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1044c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1045009ea47eSEdward Tomasz Napierala 		return;
1046009ea47eSEdward Tomasz Napierala 	}
1047009ea47eSEdward Tomasz Napierala 
104873e2e95dSAlexander Motin 	ccb = io->io_ccb;
104973e2e95dSAlexander Motin 	csio = &ccb->csio;
1050009ea47eSEdward Tomasz Napierala 
1051d43c9ec1SEdward Tomasz Napierala 	if (io->io_received + data_segment_len > csio->dxfer_len) {
1052009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "oversize data segment (%zd bytes "
1053d43c9ec1SEdward Tomasz Napierala 		    "at offset %zd, buffer is %d)",
1054d43c9ec1SEdward Tomasz Napierala 		    data_segment_len, io->io_received, csio->dxfer_len);
1055009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1056009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1057c215ad3aSAlexander Motin 		ISCSI_SESSION_UNLOCK(is);
1058009ea47eSEdward Tomasz Napierala 		return;
1059009ea47eSEdward Tomasz Napierala 	}
1060009ea47eSEdward Tomasz Napierala 
106173e2e95dSAlexander Motin 	oreceived = io->io_received;
1062009ea47eSEdward Tomasz Napierala 	io->io_received += data_segment_len;
106373e2e95dSAlexander Motin 	received = io->io_received;
1064c215ad3aSAlexander Motin 	if ((bhsdi->bhsdi_flags & BHSDI_FLAGS_S) != 0)
1065c215ad3aSAlexander Motin 		iscsi_outstanding_remove(is, io);
1066c215ad3aSAlexander Motin 	ISCSI_SESSION_UNLOCK(is);
1067c215ad3aSAlexander Motin 
106873e2e95dSAlexander Motin 	icl_pdu_get_data(response, 0, csio->data_ptr + oreceived, data_segment_len);
1069009ea47eSEdward Tomasz Napierala 
1070009ea47eSEdward Tomasz Napierala 	/*
1071009ea47eSEdward Tomasz Napierala 	 * XXX: Check DataSN.
1072009ea47eSEdward Tomasz Napierala 	 * XXX: Check F.
1073009ea47eSEdward Tomasz Napierala 	 */
107469647b7bSEdward Tomasz Napierala 	if ((bhsdi->bhsdi_flags & BHSDI_FLAGS_S) == 0) {
107569647b7bSEdward Tomasz Napierala 		/*
107669647b7bSEdward Tomasz Napierala 		 * Nothing more to do.
107769647b7bSEdward Tomasz Napierala 		 */
107869647b7bSEdward Tomasz Napierala 		icl_pdu_free(response);
107969647b7bSEdward Tomasz Napierala 		return;
108069647b7bSEdward Tomasz Napierala 	}
108169647b7bSEdward Tomasz Napierala 
1082009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "got S flag; status 0x%x", bhsdi->bhsdi_status);
1083009ea47eSEdward Tomasz Napierala 	if (bhsdi->bhsdi_status == 0) {
108473e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
1085009ea47eSEdward Tomasz Napierala 	} else {
108673e2e95dSAlexander Motin 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
108773e2e95dSAlexander Motin 			xpt_freeze_devq(ccb->ccb_h.path, 1);
1088009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
1089009ea47eSEdward Tomasz Napierala 		}
109073e2e95dSAlexander Motin 		ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | CAM_DEV_QFRZN;
1091009ea47eSEdward Tomasz Napierala 		csio->scsi_status = bhsdi->bhsdi_status;
1092009ea47eSEdward Tomasz Napierala 	}
109369647b7bSEdward Tomasz Napierala 
109469647b7bSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
109573e2e95dSAlexander Motin 		KASSERT(received <= csio->dxfer_len,
109673e2e95dSAlexander Motin 		    ("received > csio->dxfer_len"));
109773e2e95dSAlexander Motin 		if (received < csio->dxfer_len) {
109869647b7bSEdward Tomasz Napierala 			csio->resid = ntohl(bhsdi->bhsdi_residual_count);
109973e2e95dSAlexander Motin 			if (csio->resid != csio->dxfer_len - received) {
110069647b7bSEdward Tomasz Napierala 				ISCSI_SESSION_WARN(is, "underflow mismatch: "
110169647b7bSEdward Tomasz Napierala 				    "target indicates %d, we calculated %zd",
110273e2e95dSAlexander Motin 				    csio->resid, csio->dxfer_len - received);
110369647b7bSEdward Tomasz Napierala 			}
110473e2e95dSAlexander Motin 			csio->resid = csio->dxfer_len - received;
110569647b7bSEdward Tomasz Napierala 		}
1106009ea47eSEdward Tomasz Napierala 	}
1107009ea47eSEdward Tomasz Napierala 
110873e2e95dSAlexander Motin 	xpt_done(ccb);
1109009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1110009ea47eSEdward Tomasz Napierala }
1111009ea47eSEdward Tomasz Napierala 
1112009ea47eSEdward Tomasz Napierala static void
1113009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_logout_response(struct icl_pdu *response)
1114009ea47eSEdward Tomasz Napierala {
1115009ea47eSEdward Tomasz Napierala 
1116009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(PDU_SESSION(response), "logout response");
1117009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1118009ea47eSEdward Tomasz Napierala }
1119009ea47eSEdward Tomasz Napierala 
1120009ea47eSEdward Tomasz Napierala static void
1121009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_r2t(struct icl_pdu *response)
1122009ea47eSEdward Tomasz Napierala {
1123009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
1124009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1125009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_r2t *bhsr2t;
1126009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_data_out *bhsdo;
1127009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
1128009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
1129009ea47eSEdward Tomasz Napierala 	size_t off, len, total_len;
1130009ea47eSEdward Tomasz Napierala 	int error;
1131009ea47eSEdward Tomasz Napierala 
1132009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1133009ea47eSEdward Tomasz Napierala 
1134009ea47eSEdward Tomasz Napierala 	bhsr2t = (struct iscsi_bhs_r2t *)response->ip_bhs;
1135009ea47eSEdward Tomasz Napierala 	io = iscsi_outstanding_find(is, bhsr2t->bhsr2t_initiator_task_tag);
1136aa75114cSAlexander Motin 	if (io == NULL || io->io_ccb == NULL) {
1137009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "bad itt 0x%x; reconnecting",
1138009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_initiator_task_tag);
1139009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1140009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1141009ea47eSEdward Tomasz Napierala 		return;
1142009ea47eSEdward Tomasz Napierala 	}
1143009ea47eSEdward Tomasz Napierala 
1144009ea47eSEdward Tomasz Napierala 	csio = &io->io_ccb->csio;
1145009ea47eSEdward Tomasz Napierala 
1146009ea47eSEdward Tomasz Napierala 	if ((csio->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_OUT) {
1147009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "received R2T for read command; reconnecting");
1148009ea47eSEdward Tomasz Napierala 		icl_pdu_free(response);
1149009ea47eSEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1150009ea47eSEdward Tomasz Napierala 		return;
1151009ea47eSEdward Tomasz Napierala 	}
1152009ea47eSEdward Tomasz Napierala 
1153009ea47eSEdward Tomasz Napierala 	/*
1154009ea47eSEdward Tomasz Napierala 	 * XXX: Verify R2TSN.
1155009ea47eSEdward Tomasz Napierala 	 */
1156009ea47eSEdward Tomasz Napierala 
1157009ea47eSEdward Tomasz Napierala 	io->io_datasn = 0;
1158d43c9ec1SEdward Tomasz Napierala 
1159009ea47eSEdward Tomasz Napierala 	off = ntohl(bhsr2t->bhsr2t_buffer_offset);
1160d43c9ec1SEdward Tomasz Napierala 	if (off > csio->dxfer_len) {
1161d43c9ec1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requested invalid offset "
1162d43c9ec1SEdward Tomasz Napierala 		    "%zd, buffer is is %d; reconnecting", off, csio->dxfer_len);
1163d43c9ec1SEdward Tomasz Napierala 		icl_pdu_free(response);
1164d43c9ec1SEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1165d43c9ec1SEdward Tomasz Napierala 		return;
1166d43c9ec1SEdward Tomasz Napierala 	}
1167d43c9ec1SEdward Tomasz Napierala 
1168009ea47eSEdward Tomasz Napierala 	total_len = ntohl(bhsr2t->bhsr2t_desired_data_transfer_length);
1169d43c9ec1SEdward Tomasz Napierala 	if (total_len == 0 || total_len > csio->dxfer_len) {
1170d43c9ec1SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requested invalid length "
1171d43c9ec1SEdward Tomasz Napierala 		    "%zd, buffer is %d; reconnecting", total_len, csio->dxfer_len);
1172d43c9ec1SEdward Tomasz Napierala 		icl_pdu_free(response);
1173d43c9ec1SEdward Tomasz Napierala 		iscsi_session_reconnect(is);
1174d43c9ec1SEdward Tomasz Napierala 		return;
1175d43c9ec1SEdward Tomasz Napierala 	}
1176009ea47eSEdward Tomasz Napierala 
1177009ea47eSEdward Tomasz Napierala 	//ISCSI_SESSION_DEBUG(is, "r2t; off %zd, len %zd", off, total_len);
1178009ea47eSEdward Tomasz Napierala 
1179009ea47eSEdward Tomasz Napierala 	for (;;) {
1180009ea47eSEdward Tomasz Napierala 		len = total_len;
1181009ea47eSEdward Tomasz Napierala 
1182009ea47eSEdward Tomasz Napierala 		if (len > is->is_max_data_segment_length)
1183009ea47eSEdward Tomasz Napierala 			len = is->is_max_data_segment_length;
1184009ea47eSEdward Tomasz Napierala 
1185009ea47eSEdward Tomasz Napierala 		if (off + len > csio->dxfer_len) {
1186d43c9ec1SEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "target requested invalid "
1187d43c9ec1SEdward Tomasz Napierala 			    "length/offset %zd, buffer is %d; reconnecting",
1188009ea47eSEdward Tomasz Napierala 			    off + len, csio->dxfer_len);
1189009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
1190009ea47eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
1191009ea47eSEdward Tomasz Napierala 			return;
1192009ea47eSEdward Tomasz Napierala 		}
1193009ea47eSEdward Tomasz Napierala 
1194d2d52b00SEdward Tomasz Napierala 		request = icl_pdu_new(response->ip_conn, M_NOWAIT);
1195009ea47eSEdward Tomasz Napierala 		if (request == NULL) {
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 		bhsdo = (struct iscsi_bhs_data_out *)request->ip_bhs;
1202009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_opcode = ISCSI_BHS_OPCODE_SCSI_DATA_OUT;
1203009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_lun = bhsr2t->bhsr2t_lun;
1204009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_initiator_task_tag =
1205009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_initiator_task_tag;
1206009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_target_transfer_tag =
1207009ea47eSEdward Tomasz Napierala 		    bhsr2t->bhsr2t_target_transfer_tag;
1208009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_datasn = htonl(io->io_datasn++);
1209009ea47eSEdward Tomasz Napierala 		bhsdo->bhsdo_buffer_offset = htonl(off);
1210d43c9ec1SEdward Tomasz Napierala 		error = icl_pdu_append_data(request, csio->data_ptr + off, len,
1211d43c9ec1SEdward Tomasz Napierala 		    M_NOWAIT);
1212009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1213d43c9ec1SEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate memory; "
1214d43c9ec1SEdward Tomasz Napierala 			    "reconnecting");
1215009ea47eSEdward Tomasz Napierala 			icl_pdu_free(request);
1216009ea47eSEdward Tomasz Napierala 			icl_pdu_free(response);
1217009ea47eSEdward Tomasz Napierala 			iscsi_session_reconnect(is);
1218009ea47eSEdward Tomasz Napierala 			return;
1219009ea47eSEdward Tomasz Napierala 		}
1220009ea47eSEdward Tomasz Napierala 
1221009ea47eSEdward Tomasz Napierala 		off += len;
1222009ea47eSEdward Tomasz Napierala 		total_len -= len;
1223009ea47eSEdward Tomasz Napierala 
1224009ea47eSEdward Tomasz Napierala 		if (total_len == 0) {
1225009ea47eSEdward Tomasz Napierala 			bhsdo->bhsdo_flags |= BHSDO_FLAGS_F;
1226009ea47eSEdward Tomasz Napierala 			//ISCSI_SESSION_DEBUG(is, "setting F, off %zd", off);
1227009ea47eSEdward Tomasz Napierala 		} else {
1228009ea47eSEdward Tomasz Napierala 			//ISCSI_SESSION_DEBUG(is, "not finished, off %zd", off);
1229009ea47eSEdward Tomasz Napierala 		}
1230009ea47eSEdward Tomasz Napierala 
1231009ea47eSEdward Tomasz Napierala 		iscsi_pdu_queue_locked(request);
1232009ea47eSEdward Tomasz Napierala 
1233009ea47eSEdward Tomasz Napierala 		if (total_len == 0)
1234009ea47eSEdward Tomasz Napierala 			break;
1235009ea47eSEdward Tomasz Napierala 	}
1236009ea47eSEdward Tomasz Napierala 
1237009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1238009ea47eSEdward Tomasz Napierala }
1239009ea47eSEdward Tomasz Napierala 
1240009ea47eSEdward Tomasz Napierala static void
1241009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_async_message(struct icl_pdu *response)
1242009ea47eSEdward Tomasz Napierala {
1243009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_asynchronous_message *bhsam;
1244009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1245009ea47eSEdward Tomasz Napierala 
1246009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1247009ea47eSEdward Tomasz Napierala 	bhsam = (struct iscsi_bhs_asynchronous_message *)response->ip_bhs;
1248009ea47eSEdward Tomasz Napierala 	switch (bhsam->bhsam_async_event) {
1249009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_REQUESTS_LOGOUT:
1250009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target requests logout; removing session");
1251009ea47eSEdward Tomasz Napierala 		iscsi_session_logout(is);
1252009ea47eSEdward Tomasz Napierala 		iscsi_session_terminate(is);
1253009ea47eSEdward Tomasz Napierala 		break;
1254009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_TERMINATES_CONNECTION:
1255009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target indicates it will drop drop the connection");
1256009ea47eSEdward Tomasz Napierala 		break;
1257009ea47eSEdward Tomasz Napierala 	case BHSAM_EVENT_TARGET_TERMINATES_SESSION:
1258009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "target indicates it will drop drop the session");
1259009ea47eSEdward Tomasz Napierala 		break;
1260009ea47eSEdward Tomasz Napierala 	default:
1261009ea47eSEdward Tomasz Napierala 		/*
1262009ea47eSEdward Tomasz Napierala 		 * XXX: Technically, we're obligated to also handle
1263009ea47eSEdward Tomasz Napierala 		 * 	parameter renegotiation.
1264009ea47eSEdward Tomasz Napierala 		 */
1265009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "ignoring AsyncEvent %d", bhsam->bhsam_async_event);
1266009ea47eSEdward Tomasz Napierala 		break;
1267009ea47eSEdward Tomasz Napierala 	}
1268009ea47eSEdward Tomasz Napierala 
1269009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1270009ea47eSEdward Tomasz Napierala }
1271009ea47eSEdward Tomasz Napierala 
1272009ea47eSEdward Tomasz Napierala static void
1273009ea47eSEdward Tomasz Napierala iscsi_pdu_handle_reject(struct icl_pdu *response)
1274009ea47eSEdward Tomasz Napierala {
1275009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_reject *bhsr;
1276009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1277009ea47eSEdward Tomasz Napierala 
1278009ea47eSEdward Tomasz Napierala 	is = PDU_SESSION(response);
1279009ea47eSEdward Tomasz Napierala 	bhsr = (struct iscsi_bhs_reject *)response->ip_bhs;
1280009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_WARN(is, "received Reject PDU, reason 0x%x; protocol error?",
1281009ea47eSEdward Tomasz Napierala 	    bhsr->bhsr_reason);
1282009ea47eSEdward Tomasz Napierala 
1283009ea47eSEdward Tomasz Napierala 	icl_pdu_free(response);
1284009ea47eSEdward Tomasz Napierala }
1285009ea47eSEdward Tomasz Napierala 
1286009ea47eSEdward Tomasz Napierala static int
1287009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_wait(struct iscsi_softc *sc,
1288009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_request *request)
1289009ea47eSEdward Tomasz Napierala {
1290009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1291009ea47eSEdward Tomasz Napierala 	int error;
1292009ea47eSEdward Tomasz Napierala 
1293009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1294009ea47eSEdward Tomasz Napierala 	for (;;) {
1295009ea47eSEdward Tomasz Napierala 		TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
12962be596adSEdward Tomasz Napierala 			ISCSI_SESSION_LOCK(is);
1297009ea47eSEdward Tomasz Napierala 			if (is->is_waiting_for_iscsid)
1298009ea47eSEdward Tomasz Napierala 				break;
12992be596adSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1300009ea47eSEdward Tomasz Napierala 		}
1301009ea47eSEdward Tomasz Napierala 
1302009ea47eSEdward Tomasz Napierala 		if (is == NULL) {
1303009ea47eSEdward Tomasz Napierala 			/*
1304009ea47eSEdward Tomasz Napierala 			 * No session requires attention from iscsid(8); wait.
1305009ea47eSEdward Tomasz Napierala 			 */
1306009ea47eSEdward Tomasz Napierala 			error = cv_wait_sig(&sc->sc_cv, &sc->sc_lock);
1307009ea47eSEdward Tomasz Napierala 			if (error != 0) {
1308009ea47eSEdward Tomasz Napierala 				sx_sunlock(&sc->sc_lock);
1309009ea47eSEdward Tomasz Napierala 				return (error);
1310009ea47eSEdward Tomasz Napierala 			}
1311009ea47eSEdward Tomasz Napierala 			continue;
1312009ea47eSEdward Tomasz Napierala 		}
1313009ea47eSEdward Tomasz Napierala 
1314009ea47eSEdward Tomasz Napierala 		is->is_waiting_for_iscsid = false;
1315009ea47eSEdward Tomasz Napierala 		is->is_login_phase = true;
1316009ea47eSEdward Tomasz Napierala 		is->is_reason[0] = '\0';
1317009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1318009ea47eSEdward Tomasz Napierala 
1319009ea47eSEdward Tomasz Napierala 		request->idr_session_id = is->is_id;
1320ffe82e05SAlexander Motin 		memcpy(&request->idr_isid, &is->is_isid,
1321ffe82e05SAlexander Motin 		    sizeof(request->idr_isid));
1322ffe82e05SAlexander Motin 		request->idr_tsih = 0;	/* New or reinstated session. */
1323009ea47eSEdward Tomasz Napierala 		memcpy(&request->idr_conf, &is->is_conf,
1324009ea47eSEdward Tomasz Napierala 		    sizeof(request->idr_conf));
1325009ea47eSEdward Tomasz Napierala 
132682babffbSEdward Tomasz Napierala 		error = icl_limits(is->is_conf.isc_offload,
132782babffbSEdward Tomasz Napierala 		    &request->idr_limits.isl_max_data_segment_length);
132882babffbSEdward Tomasz Napierala 		if (error != 0) {
132982babffbSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "icl_limits for offload \"%s\" "
133082babffbSEdward Tomasz Napierala 			    "failed with error %d", is->is_conf.isc_offload,
133182babffbSEdward Tomasz Napierala 			    error);
133282babffbSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
133382babffbSEdward Tomasz Napierala 			return (error);
133482babffbSEdward Tomasz Napierala 		}
133582babffbSEdward Tomasz Napierala 
1336009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1337009ea47eSEdward Tomasz Napierala 		return (0);
1338009ea47eSEdward Tomasz Napierala 	}
1339009ea47eSEdward Tomasz Napierala }
1340009ea47eSEdward Tomasz Napierala 
1341009ea47eSEdward Tomasz Napierala static int
1342009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_handoff(struct iscsi_softc *sc,
1343009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_handoff *handoff)
1344009ea47eSEdward Tomasz Napierala {
1345009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1346f5cadbc4SNavdeep Parhar 	struct icl_conn *ic;
1347009ea47eSEdward Tomasz Napierala 	int error;
1348009ea47eSEdward Tomasz Napierala 
1349009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1350009ea47eSEdward Tomasz Napierala 
1351009ea47eSEdward Tomasz Napierala 	/*
1352009ea47eSEdward Tomasz Napierala 	 * Find the session to hand off socket to.
1353009ea47eSEdward Tomasz Napierala 	 */
1354009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1355009ea47eSEdward Tomasz Napierala 		if (is->is_id == handoff->idh_session_id)
1356009ea47eSEdward Tomasz Napierala 			break;
1357009ea47eSEdward Tomasz Napierala 	}
1358009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1359009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1360009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1361009ea47eSEdward Tomasz Napierala 	}
1362009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1363f5cadbc4SNavdeep Parhar 	ic = is->is_conn;
1364009ea47eSEdward Tomasz Napierala 	if (is->is_conf.isc_discovery || is->is_terminating) {
1365009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1366009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1367009ea47eSEdward Tomasz Napierala 		return (EINVAL);
1368009ea47eSEdward Tomasz Napierala 	}
13690260023fSEdward Tomasz Napierala 	if (is->is_connected) {
13700260023fSEdward Tomasz Napierala 		/*
13710260023fSEdward Tomasz Napierala 		 * This might have happened because another iscsid(8)
13720260023fSEdward Tomasz Napierala 		 * instance handed off the connection in the meantime.
13730260023fSEdward Tomasz Napierala 		 * Just return.
13740260023fSEdward Tomasz Napierala 		 */
13750260023fSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "handoff on already connected "
13760260023fSEdward Tomasz Napierala 		    "session");
13770260023fSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
13780260023fSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
13790260023fSEdward Tomasz Napierala 		return (EBUSY);
13800260023fSEdward Tomasz Napierala 	}
1381009ea47eSEdward Tomasz Napierala 
1382009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_target_alias, handoff->idh_target_alias,
1383009ea47eSEdward Tomasz Napierala 	    sizeof(is->is_target_alias));
1384ffe82e05SAlexander Motin 	is->is_tsih = handoff->idh_tsih;
1385009ea47eSEdward Tomasz Napierala 	is->is_statsn = handoff->idh_statsn;
1386009ea47eSEdward Tomasz Napierala 	is->is_initial_r2t = handoff->idh_initial_r2t;
1387009ea47eSEdward Tomasz Napierala 	is->is_immediate_data = handoff->idh_immediate_data;
1388c8b73c2cSNavdeep Parhar 
1389c8b73c2cSNavdeep Parhar 	/*
1390c8b73c2cSNavdeep Parhar 	 * Cap MaxRecvDataSegmentLength obtained from the target to the maximum
1391c8b73c2cSNavdeep Parhar 	 * size supported by our ICL module.
1392c8b73c2cSNavdeep Parhar 	 */
13937ceec7e4SNavdeep Parhar 	is->is_max_data_segment_length = min(ic->ic_max_data_segment_length,
13947ceec7e4SNavdeep Parhar 	    handoff->idh_max_data_segment_length);
1395009ea47eSEdward Tomasz Napierala 	is->is_max_burst_length = handoff->idh_max_burst_length;
1396009ea47eSEdward Tomasz Napierala 	is->is_first_burst_length = handoff->idh_first_burst_length;
1397009ea47eSEdward Tomasz Napierala 
1398009ea47eSEdward Tomasz Napierala 	if (handoff->idh_header_digest == ISCSI_DIGEST_CRC32C)
1399f5cadbc4SNavdeep Parhar 		ic->ic_header_crc32c = true;
1400009ea47eSEdward Tomasz Napierala 	else
1401f5cadbc4SNavdeep Parhar 		ic->ic_header_crc32c = false;
1402009ea47eSEdward Tomasz Napierala 	if (handoff->idh_data_digest == ISCSI_DIGEST_CRC32C)
1403f5cadbc4SNavdeep Parhar 		ic->ic_data_crc32c = true;
1404009ea47eSEdward Tomasz Napierala 	else
1405f5cadbc4SNavdeep Parhar 		ic->ic_data_crc32c = false;
1406009ea47eSEdward Tomasz Napierala 
1407009ea47eSEdward Tomasz Napierala 	is->is_cmdsn = 0;
1408cf23c509SEdward Tomasz Napierala 	is->is_expcmdsn = 0;
1409cf23c509SEdward Tomasz Napierala 	is->is_maxcmdsn = 0;
1410009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = false;
1411009ea47eSEdward Tomasz Napierala 	is->is_login_phase = false;
1412009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
1413009ea47eSEdward Tomasz Napierala 	is->is_connected = true;
1414009ea47eSEdward Tomasz Napierala 	is->is_reason[0] = '\0';
1415009ea47eSEdward Tomasz Napierala 
1416009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1417009ea47eSEdward Tomasz Napierala 
141857a4f20bSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
141957a4f20bSEdward Tomasz Napierala 	if (handoff->idh_socket != 0) {
142057a4f20bSEdward Tomasz Napierala #endif
142157a4f20bSEdward Tomasz Napierala 		/*
142257a4f20bSEdward Tomasz Napierala 		 * Handoff without using ICL proxy.
142357a4f20bSEdward Tomasz Napierala 		 */
1424f5cadbc4SNavdeep Parhar 		error = icl_conn_handoff(ic, handoff->idh_socket);
1425009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1426009ea47eSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
1427009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1428009ea47eSEdward Tomasz Napierala 			return (error);
1429009ea47eSEdward Tomasz Napierala 		}
143057a4f20bSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
143157a4f20bSEdward Tomasz Napierala 	}
1432009ea47eSEdward Tomasz Napierala #endif
1433009ea47eSEdward Tomasz Napierala 
1434009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1435009ea47eSEdward Tomasz Napierala 
1436009ea47eSEdward Tomasz Napierala 	if (is->is_sim != NULL) {
1437009ea47eSEdward Tomasz Napierala 		/*
1438009ea47eSEdward Tomasz Napierala 		 * When reconnecting, there already is SIM allocated for the session.
1439009ea47eSEdward Tomasz Napierala 		 */
1440009ea47eSEdward Tomasz Napierala 		KASSERT(is->is_simq_frozen, ("reconnect without frozen simq"));
1441009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1442009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "releasing");
1443009ea47eSEdward Tomasz Napierala 		xpt_release_simq(is->is_sim, 1);
1444009ea47eSEdward Tomasz Napierala 		is->is_simq_frozen = false;
1445009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1446009ea47eSEdward Tomasz Napierala 
1447009ea47eSEdward Tomasz Napierala 	} else {
1448009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1449009ea47eSEdward Tomasz Napierala 		is->is_devq = cam_simq_alloc(maxtags);
1450009ea47eSEdward Tomasz Napierala 		if (is->is_devq == NULL) {
1451009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate simq");
1452009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1453009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1454009ea47eSEdward Tomasz Napierala 		}
1455009ea47eSEdward Tomasz Napierala 
1456009ea47eSEdward Tomasz Napierala 		is->is_sim = cam_sim_alloc(iscsi_action, iscsi_poll, "iscsi",
1457009ea47eSEdward Tomasz Napierala 		    is, is->is_id /* unit */, &is->is_lock,
1458462cf3baSAlexander Motin 		    1, maxtags, is->is_devq);
1459009ea47eSEdward Tomasz Napierala 		if (is->is_sim == NULL) {
1460009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1461009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to allocate SIM");
1462009ea47eSEdward Tomasz Napierala 			cam_simq_free(is->is_devq);
1463009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1464009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1465009ea47eSEdward Tomasz Napierala 		}
1466009ea47eSEdward Tomasz Napierala 
1467009ea47eSEdward Tomasz Napierala 		error = xpt_bus_register(is->is_sim, NULL, 0);
1468009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1469009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1470009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to register bus");
1471009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1472009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1473009ea47eSEdward Tomasz Napierala 		}
1474009ea47eSEdward Tomasz Napierala 
1475009ea47eSEdward Tomasz Napierala 		error = xpt_create_path(&is->is_path, /*periph*/NULL,
1476009ea47eSEdward Tomasz Napierala 		    cam_sim_path(is->is_sim), CAM_TARGET_WILDCARD,
1477009ea47eSEdward Tomasz Napierala 		    CAM_LUN_WILDCARD);
1478009ea47eSEdward Tomasz Napierala 		if (error != CAM_REQ_CMP) {
1479009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1480009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is, "failed to create path");
1481009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1482009ea47eSEdward Tomasz Napierala 			return (ENOMEM);
1483009ea47eSEdward Tomasz Napierala 		}
1484009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1485009ea47eSEdward Tomasz Napierala 	}
1486009ea47eSEdward Tomasz Napierala 
1487009ea47eSEdward Tomasz Napierala 	return (0);
1488009ea47eSEdward Tomasz Napierala }
1489009ea47eSEdward Tomasz Napierala 
1490009ea47eSEdward Tomasz Napierala static int
1491009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_fail(struct iscsi_softc *sc,
1492009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_fail *fail)
1493009ea47eSEdward Tomasz Napierala {
1494009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1495009ea47eSEdward Tomasz Napierala 
1496009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1497009ea47eSEdward Tomasz Napierala 
1498009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1499009ea47eSEdward Tomasz Napierala 		if (is->is_id == fail->idf_session_id)
1500009ea47eSEdward Tomasz Napierala 			break;
1501009ea47eSEdward Tomasz Napierala 	}
1502009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1503009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1504009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1505009ea47eSEdward Tomasz Napierala 	}
1506009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1507009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_DEBUG(is, "iscsid(8) failed: %s",
1508009ea47eSEdward Tomasz Napierala 	    fail->idf_reason);
1509009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, fail->idf_reason, sizeof(is->is_reason));
1510009ea47eSEdward Tomasz Napierala 	//is->is_waiting_for_iscsid = false;
1511009ea47eSEdward Tomasz Napierala 	//is->is_login_phase = true;
1512009ea47eSEdward Tomasz Napierala 	//iscsi_session_reconnect(is);
1513009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1514009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1515009ea47eSEdward Tomasz Napierala 
1516009ea47eSEdward Tomasz Napierala 	return (0);
1517009ea47eSEdward Tomasz Napierala }
1518009ea47eSEdward Tomasz Napierala 
1519009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
1520009ea47eSEdward Tomasz Napierala static int
1521009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_connect(struct iscsi_softc *sc,
1522009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_connect *idc)
1523009ea47eSEdward Tomasz Napierala {
1524009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1525009ea47eSEdward Tomasz Napierala 	struct sockaddr *from_sa, *to_sa;
1526009ea47eSEdward Tomasz Napierala 	int error;
1527009ea47eSEdward Tomasz Napierala 
1528009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1529009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1530009ea47eSEdward Tomasz Napierala 		if (is->is_id == idc->idc_session_id)
1531009ea47eSEdward Tomasz Napierala 			break;
1532009ea47eSEdward Tomasz Napierala 	}
1533009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1534009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1535009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1536009ea47eSEdward Tomasz Napierala 	}
1537009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1538009ea47eSEdward Tomasz Napierala 
1539009ea47eSEdward Tomasz Napierala 	if (idc->idc_from_addrlen > 0) {
1540009ea47eSEdward Tomasz Napierala 		error = getsockaddr(&from_sa, (void *)idc->idc_from_addr, idc->idc_from_addrlen);
154157a4f20bSEdward Tomasz Napierala 		if (error != 0) {
154257a4f20bSEdward Tomasz Napierala 			ISCSI_SESSION_WARN(is,
154357a4f20bSEdward Tomasz Napierala 			    "getsockaddr failed with error %d", error);
1544009ea47eSEdward Tomasz Napierala 			return (error);
154557a4f20bSEdward Tomasz Napierala 		}
1546009ea47eSEdward Tomasz Napierala 	} else {
1547009ea47eSEdward Tomasz Napierala 		from_sa = NULL;
1548009ea47eSEdward Tomasz Napierala 	}
1549009ea47eSEdward Tomasz Napierala 	error = getsockaddr(&to_sa, (void *)idc->idc_to_addr, idc->idc_to_addrlen);
1550009ea47eSEdward Tomasz Napierala 	if (error != 0) {
155157a4f20bSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "getsockaddr failed with error %d",
155257a4f20bSEdward Tomasz Napierala 		    error);
1553009ea47eSEdward Tomasz Napierala 		free(from_sa, M_SONAME);
1554009ea47eSEdward Tomasz Napierala 		return (error);
1555009ea47eSEdward Tomasz Napierala 	}
1556009ea47eSEdward Tomasz Napierala 
1557009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1558009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = false;
1559009ea47eSEdward Tomasz Napierala 	is->is_login_phase = true;
1560009ea47eSEdward Tomasz Napierala 	is->is_timeout = 0;
1561009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1562009ea47eSEdward Tomasz Napierala 
1563f41492b0SEdward Tomasz Napierala 	error = icl_conn_connect(is->is_conn, idc->idc_domain,
1564009ea47eSEdward Tomasz Napierala 	    idc->idc_socktype, idc->idc_protocol, from_sa, to_sa);
1565009ea47eSEdward Tomasz Napierala 	free(from_sa, M_SONAME);
1566009ea47eSEdward Tomasz Napierala 	free(to_sa, M_SONAME);
1567009ea47eSEdward Tomasz Napierala 
1568009ea47eSEdward Tomasz Napierala 	/*
1569009ea47eSEdward Tomasz Napierala 	 * Digests are always disabled during login phase.
1570009ea47eSEdward Tomasz Napierala 	 */
1571009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_header_crc32c = false;
1572009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_data_crc32c = false;
1573009ea47eSEdward Tomasz Napierala 
1574009ea47eSEdward Tomasz Napierala 	return (error);
1575009ea47eSEdward Tomasz Napierala }
1576009ea47eSEdward Tomasz Napierala 
1577009ea47eSEdward Tomasz Napierala static int
1578009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_send(struct iscsi_softc *sc,
1579009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_send *ids)
1580009ea47eSEdward Tomasz Napierala {
1581009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1582009ea47eSEdward Tomasz Napierala 	struct icl_pdu *ip;
1583009ea47eSEdward Tomasz Napierala 	size_t datalen;
1584009ea47eSEdward Tomasz Napierala 	void *data;
1585009ea47eSEdward Tomasz Napierala 	int error;
1586009ea47eSEdward Tomasz Napierala 
1587009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1588009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1589009ea47eSEdward Tomasz Napierala 		if (is->is_id == ids->ids_session_id)
1590009ea47eSEdward Tomasz Napierala 			break;
1591009ea47eSEdward Tomasz Napierala 	}
1592009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1593009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1594009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1595009ea47eSEdward Tomasz Napierala 	}
1596009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1597009ea47eSEdward Tomasz Napierala 
1598009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase == false)
1599009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1600009ea47eSEdward Tomasz Napierala 
1601009ea47eSEdward Tomasz Napierala 	if (is->is_terminating || is->is_reconnecting)
1602009ea47eSEdward Tomasz Napierala 		return (EIO);
1603009ea47eSEdward Tomasz Napierala 
1604009ea47eSEdward Tomasz Napierala 	datalen = ids->ids_data_segment_len;
1605009ea47eSEdward Tomasz Napierala 	if (datalen > ISCSI_MAX_DATA_SEGMENT_LENGTH)
1606009ea47eSEdward Tomasz Napierala 		return (EINVAL);
1607009ea47eSEdward Tomasz Napierala 	if (datalen > 0) {
1608009ea47eSEdward Tomasz Napierala 		data = malloc(datalen, M_ISCSI, M_WAITOK);
1609009ea47eSEdward Tomasz Napierala 		error = copyin(ids->ids_data_segment, data, datalen);
1610009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1611009ea47eSEdward Tomasz Napierala 			free(data, M_ISCSI);
1612009ea47eSEdward Tomasz Napierala 			return (error);
1613009ea47eSEdward Tomasz Napierala 		}
1614009ea47eSEdward Tomasz Napierala 	}
1615009ea47eSEdward Tomasz Napierala 
1616d2d52b00SEdward Tomasz Napierala 	ip = icl_pdu_new(is->is_conn, M_WAITOK);
1617009ea47eSEdward Tomasz Napierala 	memcpy(ip->ip_bhs, ids->ids_bhs, sizeof(*ip->ip_bhs));
1618009ea47eSEdward Tomasz Napierala 	if (datalen > 0) {
1619009ea47eSEdward Tomasz Napierala 		error = icl_pdu_append_data(ip, data, datalen, M_WAITOK);
1620009ea47eSEdward Tomasz Napierala 		KASSERT(error == 0, ("icl_pdu_append_data(..., M_WAITOK) failed"));
1621009ea47eSEdward Tomasz Napierala 		free(data, M_ISCSI);
1622009ea47eSEdward Tomasz Napierala 	}
16230fbbc37dSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1624009ea47eSEdward Tomasz Napierala 	icl_pdu_queue(ip);
16250fbbc37dSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1626009ea47eSEdward Tomasz Napierala 
1627009ea47eSEdward Tomasz Napierala 	return (0);
1628009ea47eSEdward Tomasz Napierala }
1629009ea47eSEdward Tomasz Napierala 
1630009ea47eSEdward Tomasz Napierala static int
1631009ea47eSEdward Tomasz Napierala iscsi_ioctl_daemon_receive(struct iscsi_softc *sc,
1632009ea47eSEdward Tomasz Napierala     struct iscsi_daemon_receive *idr)
1633009ea47eSEdward Tomasz Napierala {
1634009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1635009ea47eSEdward Tomasz Napierala 	struct icl_pdu *ip;
1636009ea47eSEdward Tomasz Napierala 	void *data;
1637*2f0586b2SEdward Tomasz Napierala 	int error;
1638009ea47eSEdward Tomasz Napierala 
1639009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1640009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1641009ea47eSEdward Tomasz Napierala 		if (is->is_id == idr->idr_session_id)
1642009ea47eSEdward Tomasz Napierala 			break;
1643009ea47eSEdward Tomasz Napierala 	}
1644009ea47eSEdward Tomasz Napierala 	if (is == NULL) {
1645009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
1646009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1647009ea47eSEdward Tomasz Napierala 	}
1648009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1649009ea47eSEdward Tomasz Napierala 
1650009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase == false)
1651009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1652009ea47eSEdward Tomasz Napierala 
1653009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1654009ea47eSEdward Tomasz Napierala 	while (is->is_login_pdu == NULL &&
1655009ea47eSEdward Tomasz Napierala 	    is->is_terminating == false &&
1656*2f0586b2SEdward Tomasz Napierala 	    is->is_reconnecting == false) {
1657*2f0586b2SEdward Tomasz Napierala 		error = cv_wait_sig(&is->is_login_cv, &is->is_lock);
1658*2f0586b2SEdward Tomasz Napierala 		if (error != 0) {
1659*2f0586b2SEdward Tomasz Napierala 			ISCSI_SESSION_UNLOCK(is);
1660*2f0586b2SEdward Tomasz Napierala 			return (error);
1661*2f0586b2SEdward Tomasz Napierala 		}
1662*2f0586b2SEdward Tomasz Napierala 	}
1663009ea47eSEdward Tomasz Napierala 	if (is->is_terminating || is->is_reconnecting) {
1664009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1665009ea47eSEdward Tomasz Napierala 		return (EIO);
1666009ea47eSEdward Tomasz Napierala 	}
1667009ea47eSEdward Tomasz Napierala 	ip = is->is_login_pdu;
1668009ea47eSEdward Tomasz Napierala 	is->is_login_pdu = NULL;
1669009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1670009ea47eSEdward Tomasz Napierala 
1671009ea47eSEdward Tomasz Napierala 	if (ip->ip_data_len > idr->idr_data_segment_len) {
1672009ea47eSEdward Tomasz Napierala 		icl_pdu_free(ip);
1673009ea47eSEdward Tomasz Napierala 		return (EMSGSIZE);
1674009ea47eSEdward Tomasz Napierala 	}
1675009ea47eSEdward Tomasz Napierala 
1676009ea47eSEdward Tomasz Napierala 	copyout(ip->ip_bhs, idr->idr_bhs, sizeof(*ip->ip_bhs));
1677009ea47eSEdward Tomasz Napierala 	if (ip->ip_data_len > 0) {
1678009ea47eSEdward Tomasz Napierala 		data = malloc(ip->ip_data_len, M_ISCSI, M_WAITOK);
1679009ea47eSEdward Tomasz Napierala 		icl_pdu_get_data(ip, 0, data, ip->ip_data_len);
1680009ea47eSEdward Tomasz Napierala 		copyout(data, idr->idr_data_segment, ip->ip_data_len);
1681009ea47eSEdward Tomasz Napierala 		free(data, M_ISCSI);
1682009ea47eSEdward Tomasz Napierala 	}
1683009ea47eSEdward Tomasz Napierala 
1684009ea47eSEdward Tomasz Napierala 	icl_pdu_free(ip);
1685009ea47eSEdward Tomasz Napierala 
1686009ea47eSEdward Tomasz Napierala 	return (0);
1687009ea47eSEdward Tomasz Napierala }
1688009ea47eSEdward Tomasz Napierala #endif /* ICL_KERNEL_PROXY */
1689009ea47eSEdward Tomasz Napierala 
1690009ea47eSEdward Tomasz Napierala static void
1691009ea47eSEdward Tomasz Napierala iscsi_sanitize_session_conf(struct iscsi_session_conf *isc)
1692009ea47eSEdward Tomasz Napierala {
1693009ea47eSEdward Tomasz Napierala 	/*
1694009ea47eSEdward Tomasz Napierala 	 * Just make sure all the fields are null-terminated.
1695009ea47eSEdward Tomasz Napierala 	 *
1696009ea47eSEdward Tomasz Napierala 	 * XXX: This is not particularly secure.  We should
1697009ea47eSEdward Tomasz Napierala 	 * 	create our own conf and then copy in relevant
1698009ea47eSEdward Tomasz Napierala 	 * 	fields.
1699009ea47eSEdward Tomasz Napierala 	 */
1700009ea47eSEdward Tomasz Napierala 	isc->isc_initiator[ISCSI_NAME_LEN - 1] = '\0';
1701009ea47eSEdward Tomasz Napierala 	isc->isc_initiator_addr[ISCSI_ADDR_LEN - 1] = '\0';
1702009ea47eSEdward Tomasz Napierala 	isc->isc_initiator_alias[ISCSI_ALIAS_LEN - 1] = '\0';
1703009ea47eSEdward Tomasz Napierala 	isc->isc_target[ISCSI_NAME_LEN - 1] = '\0';
1704009ea47eSEdward Tomasz Napierala 	isc->isc_target_addr[ISCSI_ADDR_LEN - 1] = '\0';
1705009ea47eSEdward Tomasz Napierala 	isc->isc_user[ISCSI_NAME_LEN - 1] = '\0';
1706009ea47eSEdward Tomasz Napierala 	isc->isc_secret[ISCSI_SECRET_LEN - 1] = '\0';
1707009ea47eSEdward Tomasz Napierala 	isc->isc_mutual_user[ISCSI_NAME_LEN - 1] = '\0';
1708009ea47eSEdward Tomasz Napierala 	isc->isc_mutual_secret[ISCSI_SECRET_LEN - 1] = '\0';
1709009ea47eSEdward Tomasz Napierala }
1710009ea47eSEdward Tomasz Napierala 
171151be90b5SEdward Tomasz Napierala static bool
171251be90b5SEdward Tomasz Napierala iscsi_valid_session_conf(const struct iscsi_session_conf *isc)
171351be90b5SEdward Tomasz Napierala {
171451be90b5SEdward Tomasz Napierala 
171551be90b5SEdward Tomasz Napierala 	if (isc->isc_initiator[0] == '\0') {
171651be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_initiator");
171751be90b5SEdward Tomasz Napierala 		return (false);
171851be90b5SEdward Tomasz Napierala 	}
171951be90b5SEdward Tomasz Napierala 
172051be90b5SEdward Tomasz Napierala 	if (isc->isc_target_addr[0] == '\0') {
172151be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_target_addr");
172251be90b5SEdward Tomasz Napierala 		return (false);
172351be90b5SEdward Tomasz Napierala 	}
172451be90b5SEdward Tomasz Napierala 
172551be90b5SEdward Tomasz Napierala 	if (isc->isc_discovery != 0 && isc->isc_target[0] != 0) {
172651be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("non-empty isc_target for discovery session");
172751be90b5SEdward Tomasz Napierala 		return (false);
172851be90b5SEdward Tomasz Napierala 	}
172951be90b5SEdward Tomasz Napierala 
173051be90b5SEdward Tomasz Napierala 	if (isc->isc_discovery == 0 && isc->isc_target[0] == 0) {
173151be90b5SEdward Tomasz Napierala 		ISCSI_DEBUG("empty isc_target for non-discovery session");
173251be90b5SEdward Tomasz Napierala 		return (false);
173351be90b5SEdward Tomasz Napierala 	}
173451be90b5SEdward Tomasz Napierala 
173551be90b5SEdward Tomasz Napierala 	return (true);
173651be90b5SEdward Tomasz Napierala }
173751be90b5SEdward Tomasz Napierala 
1738009ea47eSEdward Tomasz Napierala static int
1739009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_add(struct iscsi_softc *sc, struct iscsi_session_add *isa)
1740009ea47eSEdward Tomasz Napierala {
1741009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1742009ea47eSEdward Tomasz Napierala 	const struct iscsi_session *is2;
1743009ea47eSEdward Tomasz Napierala 	int error;
1744009ea47eSEdward Tomasz Napierala 
1745009ea47eSEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&isa->isa_conf);
174651be90b5SEdward Tomasz Napierala 	if (iscsi_valid_session_conf(&isa->isa_conf) == false)
174751be90b5SEdward Tomasz Napierala 		return (EINVAL);
1748009ea47eSEdward Tomasz Napierala 
1749009ea47eSEdward Tomasz Napierala 	is = malloc(sizeof(*is), M_ISCSI, M_ZERO | M_WAITOK);
1750009ea47eSEdward Tomasz Napierala 	memcpy(&is->is_conf, &isa->isa_conf, sizeof(is->is_conf));
1751009ea47eSEdward Tomasz Napierala 
1752009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
1753009ea47eSEdward Tomasz Napierala 
1754009ea47eSEdward Tomasz Napierala 	/*
1755009ea47eSEdward Tomasz Napierala 	 * Prevent duplicates.
1756009ea47eSEdward Tomasz Napierala 	 */
1757009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is2, &sc->sc_sessions, is_next) {
17587843bd03SEdward Tomasz Napierala 		if (!!is->is_conf.isc_discovery !=
17597843bd03SEdward Tomasz Napierala 		    !!is2->is_conf.isc_discovery)
17607843bd03SEdward Tomasz Napierala 			continue;
17617843bd03SEdward Tomasz Napierala 
17627843bd03SEdward Tomasz Napierala 		if (strcmp(is->is_conf.isc_target_addr,
17637843bd03SEdward Tomasz Napierala 		    is2->is_conf.isc_target_addr) != 0)
17647843bd03SEdward Tomasz Napierala 			continue;
17657843bd03SEdward Tomasz Napierala 
17667843bd03SEdward Tomasz Napierala 		if (is->is_conf.isc_discovery == 0 &&
17677843bd03SEdward Tomasz Napierala 		    strcmp(is->is_conf.isc_target,
17687843bd03SEdward Tomasz Napierala 		    is2->is_conf.isc_target) != 0)
17697843bd03SEdward Tomasz Napierala 			continue;
17707843bd03SEdward Tomasz Napierala 
1771009ea47eSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
17727843bd03SEdward Tomasz Napierala 		free(is, M_ISCSI);
1773009ea47eSEdward Tomasz Napierala 		return (EBUSY);
1774009ea47eSEdward Tomasz Napierala 	}
1775009ea47eSEdward Tomasz Napierala 
177682babffbSEdward Tomasz Napierala 	is->is_conn = icl_new_conn(is->is_conf.isc_offload,
177782babffbSEdward Tomasz Napierala 	    "iscsi", &is->is_lock);
177882babffbSEdward Tomasz Napierala 	if (is->is_conn == NULL) {
177982babffbSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
178082babffbSEdward Tomasz Napierala 		free(is, M_ISCSI);
178182babffbSEdward Tomasz Napierala 		return (EINVAL);
178282babffbSEdward Tomasz Napierala 	}
1783009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_receive = iscsi_receive_callback;
1784009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_error = iscsi_error_callback;
1785009ea47eSEdward Tomasz Napierala 	is->is_conn->ic_prv0 = is;
1786009ea47eSEdward Tomasz Napierala 	TAILQ_INIT(&is->is_outstanding);
178716c158a5SEdward Tomasz Napierala 	STAILQ_INIT(&is->is_postponed);
1788009ea47eSEdward Tomasz Napierala 	mtx_init(&is->is_lock, "iscsi_lock", NULL, MTX_DEF);
1789009ea47eSEdward Tomasz Napierala 	cv_init(&is->is_maintenance_cv, "iscsi_mt");
1790009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
1791009ea47eSEdward Tomasz Napierala 	cv_init(&is->is_login_cv, "iscsi_login");
1792009ea47eSEdward Tomasz Napierala #endif
1793009ea47eSEdward Tomasz Napierala 
1794009ea47eSEdward Tomasz Napierala 	is->is_softc = sc;
1795009ea47eSEdward Tomasz Napierala 	sc->sc_last_session_id++;
1796009ea47eSEdward Tomasz Napierala 	is->is_id = sc->sc_last_session_id;
1797ffe82e05SAlexander Motin 	is->is_isid[0] = 0x80; /* RFC 3720, 10.12.5: 10b, "Random" ISID. */
1798ffe82e05SAlexander Motin 	arc4rand(&is->is_isid[1], 5, 0);
1799ffe82e05SAlexander Motin 	is->is_tsih = 0;
1800009ea47eSEdward Tomasz Napierala 	callout_init(&is->is_callout, 1);
1801009ea47eSEdward Tomasz Napierala 
1802009ea47eSEdward Tomasz Napierala 	error = kthread_add(iscsi_maintenance_thread, is, NULL, NULL, 0, 0, "iscsimt");
1803009ea47eSEdward Tomasz Napierala 	if (error != 0) {
1804009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "kthread_add(9) failed with error %d", error);
180509f2b94bSEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
1806009ea47eSEdward Tomasz Napierala 		return (error);
1807009ea47eSEdward Tomasz Napierala 	}
1808009ea47eSEdward Tomasz Napierala 
180909f2b94bSEdward Tomasz Napierala 	callout_reset(&is->is_callout, 1 * hz, iscsi_callout, is);
181009f2b94bSEdward Tomasz Napierala 	TAILQ_INSERT_TAIL(&sc->sc_sessions, is, is_next);
181109f2b94bSEdward Tomasz Napierala 
1812009ea47eSEdward Tomasz Napierala 	/*
1813009ea47eSEdward Tomasz Napierala 	 * Trigger immediate reconnection.
1814009ea47eSEdward Tomasz Napierala 	 */
18152be596adSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK(is);
1816009ea47eSEdward Tomasz Napierala 	is->is_waiting_for_iscsid = true;
1817009ea47eSEdward Tomasz Napierala 	strlcpy(is->is_reason, "Waiting for iscsid(8)", sizeof(is->is_reason));
18182be596adSEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
1819009ea47eSEdward Tomasz Napierala 	cv_signal(&sc->sc_cv);
1820009ea47eSEdward Tomasz Napierala 
1821009ea47eSEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
1822009ea47eSEdward Tomasz Napierala 
1823009ea47eSEdward Tomasz Napierala 	return (0);
1824009ea47eSEdward Tomasz Napierala }
1825009ea47eSEdward Tomasz Napierala 
1826009ea47eSEdward Tomasz Napierala static bool
1827009ea47eSEdward Tomasz Napierala iscsi_session_conf_matches(unsigned int id1, const struct iscsi_session_conf *c1,
1828009ea47eSEdward Tomasz Napierala     unsigned int id2, const struct iscsi_session_conf *c2)
1829009ea47eSEdward Tomasz Napierala {
18306cc1e267SEdward Tomasz Napierala 
18316cc1e267SEdward Tomasz Napierala 	if (id2 != 0 && id2 != id1)
1832009ea47eSEdward Tomasz Napierala 		return (false);
18336cc1e267SEdward Tomasz Napierala 	if (c2->isc_target[0] != '\0' &&
18346cc1e267SEdward Tomasz Napierala 	    strcmp(c1->isc_target, c2->isc_target) != 0)
18356cc1e267SEdward Tomasz Napierala 		return (false);
18366cc1e267SEdward Tomasz Napierala 	if (c2->isc_target_addr[0] != '\0' &&
18376cc1e267SEdward Tomasz Napierala 	    strcmp(c1->isc_target_addr, c2->isc_target_addr) != 0)
18386cc1e267SEdward Tomasz Napierala 		return (false);
18396cc1e267SEdward Tomasz Napierala 	return (true);
1840009ea47eSEdward Tomasz Napierala }
1841009ea47eSEdward Tomasz Napierala 
1842009ea47eSEdward Tomasz Napierala static int
1843009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_remove(struct iscsi_softc *sc,
1844009ea47eSEdward Tomasz Napierala     struct iscsi_session_remove *isr)
1845009ea47eSEdward Tomasz Napierala {
1846009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is, *tmp;
1847009ea47eSEdward Tomasz Napierala 	bool found = false;
1848009ea47eSEdward Tomasz Napierala 
1849009ea47eSEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&isr->isr_conf);
1850009ea47eSEdward Tomasz Napierala 
1851009ea47eSEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
1852009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH_SAFE(is, &sc->sc_sessions, is_next, tmp) {
1853009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
1854009ea47eSEdward Tomasz Napierala 		if (iscsi_session_conf_matches(is->is_id, &is->is_conf,
1855009ea47eSEdward Tomasz Napierala 		    isr->isr_session_id, &isr->isr_conf)) {
1856009ea47eSEdward Tomasz Napierala 			found = true;
1857009ea47eSEdward Tomasz Napierala 			iscsi_session_logout(is);
1858009ea47eSEdward Tomasz Napierala 			iscsi_session_terminate(is);
1859009ea47eSEdward Tomasz Napierala 		}
1860009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
1861009ea47eSEdward Tomasz Napierala 	}
1862009ea47eSEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
1863009ea47eSEdward Tomasz Napierala 
1864009ea47eSEdward Tomasz Napierala 	if (!found)
1865009ea47eSEdward Tomasz Napierala 		return (ESRCH);
1866009ea47eSEdward Tomasz Napierala 
1867009ea47eSEdward Tomasz Napierala 	return (0);
1868009ea47eSEdward Tomasz Napierala }
1869009ea47eSEdward Tomasz Napierala 
1870009ea47eSEdward Tomasz Napierala static int
1871009ea47eSEdward Tomasz Napierala iscsi_ioctl_session_list(struct iscsi_softc *sc, struct iscsi_session_list *isl)
1872009ea47eSEdward Tomasz Napierala {
1873009ea47eSEdward Tomasz Napierala 	int error;
1874009ea47eSEdward Tomasz Napierala 	unsigned int i = 0;
1875009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
1876009ea47eSEdward Tomasz Napierala 	struct iscsi_session_state iss;
1877009ea47eSEdward Tomasz Napierala 
1878009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
1879009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
1880009ea47eSEdward Tomasz Napierala 		if (i >= isl->isl_nentries) {
1881009ea47eSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
1882009ea47eSEdward Tomasz Napierala 			return (EMSGSIZE);
1883009ea47eSEdward Tomasz Napierala 		}
1884009ea47eSEdward Tomasz Napierala 		memset(&iss, 0, sizeof(iss));
1885009ea47eSEdward Tomasz Napierala 		memcpy(&iss.iss_conf, &is->is_conf, sizeof(iss.iss_conf));
1886009ea47eSEdward Tomasz Napierala 		iss.iss_id = is->is_id;
1887009ea47eSEdward Tomasz Napierala 		strlcpy(iss.iss_target_alias, is->is_target_alias, sizeof(iss.iss_target_alias));
1888009ea47eSEdward Tomasz Napierala 		strlcpy(iss.iss_reason, is->is_reason, sizeof(iss.iss_reason));
188982babffbSEdward Tomasz Napierala 		strlcpy(iss.iss_offload, is->is_conn->ic_offload, sizeof(iss.iss_offload));
1890009ea47eSEdward Tomasz Napierala 
1891009ea47eSEdward Tomasz Napierala 		if (is->is_conn->ic_header_crc32c)
1892009ea47eSEdward Tomasz Napierala 			iss.iss_header_digest = ISCSI_DIGEST_CRC32C;
1893009ea47eSEdward Tomasz Napierala 		else
1894009ea47eSEdward Tomasz Napierala 			iss.iss_header_digest = ISCSI_DIGEST_NONE;
1895009ea47eSEdward Tomasz Napierala 
1896009ea47eSEdward Tomasz Napierala 		if (is->is_conn->ic_data_crc32c)
1897009ea47eSEdward Tomasz Napierala 			iss.iss_data_digest = ISCSI_DIGEST_CRC32C;
1898009ea47eSEdward Tomasz Napierala 		else
1899009ea47eSEdward Tomasz Napierala 			iss.iss_data_digest = ISCSI_DIGEST_NONE;
1900009ea47eSEdward Tomasz Napierala 
1901009ea47eSEdward Tomasz Napierala 		iss.iss_max_data_segment_length = is->is_max_data_segment_length;
1902009ea47eSEdward Tomasz Napierala 		iss.iss_immediate_data = is->is_immediate_data;
1903009ea47eSEdward Tomasz Napierala 		iss.iss_connected = is->is_connected;
1904009ea47eSEdward Tomasz Napierala 
1905009ea47eSEdward Tomasz Napierala 		error = copyout(&iss, isl->isl_pstates + i, sizeof(iss));
1906009ea47eSEdward Tomasz Napierala 		if (error != 0) {
1907009ea47eSEdward Tomasz Napierala 			sx_sunlock(&sc->sc_lock);
1908009ea47eSEdward Tomasz Napierala 			return (error);
1909009ea47eSEdward Tomasz Napierala 		}
1910009ea47eSEdward Tomasz Napierala 		i++;
1911009ea47eSEdward Tomasz Napierala 	}
1912009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
1913009ea47eSEdward Tomasz Napierala 
1914009ea47eSEdward Tomasz Napierala 	isl->isl_nentries = i;
1915009ea47eSEdward Tomasz Napierala 
1916009ea47eSEdward Tomasz Napierala 	return (0);
1917009ea47eSEdward Tomasz Napierala }
1918009ea47eSEdward Tomasz Napierala 
1919009ea47eSEdward Tomasz Napierala static int
192051be90b5SEdward Tomasz Napierala iscsi_ioctl_session_modify(struct iscsi_softc *sc,
192151be90b5SEdward Tomasz Napierala     struct iscsi_session_modify *ism)
192251be90b5SEdward Tomasz Napierala {
192351be90b5SEdward Tomasz Napierala 	struct iscsi_session *is;
192451be90b5SEdward Tomasz Napierala 
192551be90b5SEdward Tomasz Napierala 	iscsi_sanitize_session_conf(&ism->ism_conf);
192651be90b5SEdward Tomasz Napierala 	if (iscsi_valid_session_conf(&ism->ism_conf) == false)
192751be90b5SEdward Tomasz Napierala 		return (EINVAL);
192851be90b5SEdward Tomasz Napierala 
192951be90b5SEdward Tomasz Napierala 	sx_xlock(&sc->sc_lock);
193051be90b5SEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
193151be90b5SEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
193251be90b5SEdward Tomasz Napierala 		if (is->is_id == ism->ism_session_id)
193351be90b5SEdward Tomasz Napierala 			break;
193451be90b5SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
193551be90b5SEdward Tomasz Napierala 	}
193651be90b5SEdward Tomasz Napierala 	if (is == NULL) {
193751be90b5SEdward Tomasz Napierala 		sx_xunlock(&sc->sc_lock);
193851be90b5SEdward Tomasz Napierala 		return (ESRCH);
193951be90b5SEdward Tomasz Napierala 	}
194051be90b5SEdward Tomasz Napierala 	sx_xunlock(&sc->sc_lock);
194151be90b5SEdward Tomasz Napierala 
194251be90b5SEdward Tomasz Napierala 	memcpy(&is->is_conf, &ism->ism_conf, sizeof(is->is_conf));
194351be90b5SEdward Tomasz Napierala 	ISCSI_SESSION_UNLOCK(is);
194451be90b5SEdward Tomasz Napierala 
194551be90b5SEdward Tomasz Napierala 	iscsi_session_reconnect(is);
194651be90b5SEdward Tomasz Napierala 
194751be90b5SEdward Tomasz Napierala 	return (0);
194851be90b5SEdward Tomasz Napierala }
194951be90b5SEdward Tomasz Napierala 
195051be90b5SEdward Tomasz Napierala static int
1951009ea47eSEdward Tomasz Napierala iscsi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
1952009ea47eSEdward Tomasz Napierala     struct thread *td)
1953009ea47eSEdward Tomasz Napierala {
1954009ea47eSEdward Tomasz Napierala 	struct iscsi_softc *sc;
1955009ea47eSEdward Tomasz Napierala 
1956009ea47eSEdward Tomasz Napierala 	sc = dev->si_drv1;
1957009ea47eSEdward Tomasz Napierala 
1958009ea47eSEdward Tomasz Napierala 	switch (cmd) {
1959009ea47eSEdward Tomasz Napierala 	case ISCSIDWAIT:
1960009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_wait(sc,
1961009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_request *)arg));
1962009ea47eSEdward Tomasz Napierala 	case ISCSIDHANDOFF:
1963009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_handoff(sc,
1964009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_handoff *)arg));
1965009ea47eSEdward Tomasz Napierala 	case ISCSIDFAIL:
1966009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_fail(sc,
1967009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_fail *)arg));
1968009ea47eSEdward Tomasz Napierala #ifdef ICL_KERNEL_PROXY
1969009ea47eSEdward Tomasz Napierala 	case ISCSIDCONNECT:
1970009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_connect(sc,
1971009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_connect *)arg));
1972009ea47eSEdward Tomasz Napierala 	case ISCSIDSEND:
1973009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_send(sc,
1974009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_send *)arg));
1975009ea47eSEdward Tomasz Napierala 	case ISCSIDRECEIVE:
1976009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_daemon_receive(sc,
1977009ea47eSEdward Tomasz Napierala 		    (struct iscsi_daemon_receive *)arg));
1978009ea47eSEdward Tomasz Napierala #endif /* ICL_KERNEL_PROXY */
1979009ea47eSEdward Tomasz Napierala 	case ISCSISADD:
1980009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_add(sc,
1981009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_add *)arg));
1982009ea47eSEdward Tomasz Napierala 	case ISCSISREMOVE:
1983009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_remove(sc,
1984009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_remove *)arg));
1985009ea47eSEdward Tomasz Napierala 	case ISCSISLIST:
1986009ea47eSEdward Tomasz Napierala 		return (iscsi_ioctl_session_list(sc,
1987009ea47eSEdward Tomasz Napierala 		    (struct iscsi_session_list *)arg));
198851be90b5SEdward Tomasz Napierala 	case ISCSISMODIFY:
198951be90b5SEdward Tomasz Napierala 		return (iscsi_ioctl_session_modify(sc,
199051be90b5SEdward Tomasz Napierala 		    (struct iscsi_session_modify *)arg));
1991009ea47eSEdward Tomasz Napierala 	default:
1992009ea47eSEdward Tomasz Napierala 		return (EINVAL);
1993009ea47eSEdward Tomasz Napierala 	}
1994009ea47eSEdward Tomasz Napierala }
1995009ea47eSEdward Tomasz Napierala 
1996009ea47eSEdward Tomasz Napierala static struct iscsi_outstanding *
1997009ea47eSEdward Tomasz Napierala iscsi_outstanding_find(struct iscsi_session *is, uint32_t initiator_task_tag)
1998009ea47eSEdward Tomasz Napierala {
1999009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
2000009ea47eSEdward Tomasz Napierala 
2001009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2002009ea47eSEdward Tomasz Napierala 
2003009ea47eSEdward Tomasz Napierala 	TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2004009ea47eSEdward Tomasz Napierala 		if (io->io_initiator_task_tag == initiator_task_tag)
2005009ea47eSEdward Tomasz Napierala 			return (io);
2006009ea47eSEdward Tomasz Napierala 	}
2007009ea47eSEdward Tomasz Napierala 	return (NULL);
2008009ea47eSEdward Tomasz Napierala }
2009009ea47eSEdward Tomasz Napierala 
2010aa75114cSAlexander Motin static struct iscsi_outstanding *
2011aa75114cSAlexander Motin iscsi_outstanding_find_ccb(struct iscsi_session *is, union ccb *ccb)
2012aa75114cSAlexander Motin {
2013aa75114cSAlexander Motin 	struct iscsi_outstanding *io;
2014aa75114cSAlexander Motin 
2015aa75114cSAlexander Motin 	ISCSI_SESSION_LOCK_ASSERT(is);
2016aa75114cSAlexander Motin 
2017aa75114cSAlexander Motin 	TAILQ_FOREACH(io, &is->is_outstanding, io_next) {
2018aa75114cSAlexander Motin 		if (io->io_ccb == ccb)
2019aa75114cSAlexander Motin 			return (io);
2020aa75114cSAlexander Motin 	}
2021aa75114cSAlexander Motin 	return (NULL);
2022aa75114cSAlexander Motin }
2023aa75114cSAlexander Motin 
2024aa75114cSAlexander Motin static struct iscsi_outstanding *
2025604c023fSEdward Tomasz Napierala iscsi_outstanding_add(struct iscsi_session *is, struct icl_pdu *request,
20267a03d007SEdward Tomasz Napierala     union ccb *ccb, uint32_t *initiator_task_tagp)
2027009ea47eSEdward Tomasz Napierala {
2028009ea47eSEdward Tomasz Napierala 	struct iscsi_outstanding *io;
20297a03d007SEdward Tomasz Napierala 	int error;
2030009ea47eSEdward Tomasz Napierala 
2031009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2032009ea47eSEdward Tomasz Napierala 
2033009ea47eSEdward Tomasz Napierala 	io = uma_zalloc(iscsi_outstanding_zone, M_NOWAIT | M_ZERO);
2034009ea47eSEdward Tomasz Napierala 	if (io == NULL) {
20357a03d007SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is, "failed to allocate %zd bytes",
20367a03d007SEdward Tomasz Napierala 		    sizeof(*io));
2037aa75114cSAlexander Motin 		return (NULL);
2038009ea47eSEdward Tomasz Napierala 	}
20397a03d007SEdward Tomasz Napierala 
2040604c023fSEdward Tomasz Napierala 	error = icl_conn_task_setup(is->is_conn, request, &ccb->csio,
20417a03d007SEdward Tomasz Napierala 	    initiator_task_tagp, &io->io_icl_prv);
20427a03d007SEdward Tomasz Napierala 	if (error != 0) {
20437a03d007SEdward Tomasz Napierala 		ISCSI_SESSION_WARN(is,
20447a03d007SEdward Tomasz Napierala 		    "icl_conn_task_setup() failed with error %d", error);
20457a03d007SEdward Tomasz Napierala 		uma_zfree(iscsi_outstanding_zone, io);
20467a03d007SEdward Tomasz Napierala 		return (NULL);
20477a03d007SEdward Tomasz Napierala 	}
20487a03d007SEdward Tomasz Napierala 
20497a03d007SEdward Tomasz Napierala 	KASSERT(iscsi_outstanding_find(is, *initiator_task_tagp) == NULL,
20507a03d007SEdward Tomasz Napierala 	    ("initiator_task_tag 0x%x already added", *initiator_task_tagp));
20517a03d007SEdward Tomasz Napierala 
20527a03d007SEdward Tomasz Napierala 	io->io_initiator_task_tag = *initiator_task_tagp;
2053009ea47eSEdward Tomasz Napierala 	io->io_ccb = ccb;
2054009ea47eSEdward Tomasz Napierala 	TAILQ_INSERT_TAIL(&is->is_outstanding, io, io_next);
2055aa75114cSAlexander Motin 	return (io);
2056009ea47eSEdward Tomasz Napierala }
2057009ea47eSEdward Tomasz Napierala 
2058009ea47eSEdward Tomasz Napierala static void
2059009ea47eSEdward Tomasz Napierala iscsi_outstanding_remove(struct iscsi_session *is, struct iscsi_outstanding *io)
2060009ea47eSEdward Tomasz Napierala {
2061009ea47eSEdward Tomasz Napierala 
2062009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2063009ea47eSEdward Tomasz Napierala 
20647a03d007SEdward Tomasz Napierala 	icl_conn_task_done(is->is_conn, io->io_icl_prv);
2065009ea47eSEdward Tomasz Napierala 	TAILQ_REMOVE(&is->is_outstanding, io, io_next);
2066009ea47eSEdward Tomasz Napierala 	uma_zfree(iscsi_outstanding_zone, io);
2067009ea47eSEdward Tomasz Napierala }
2068009ea47eSEdward Tomasz Napierala 
2069009ea47eSEdward Tomasz Napierala static void
2070aa75114cSAlexander Motin iscsi_action_abort(struct iscsi_session *is, union ccb *ccb)
2071aa75114cSAlexander Motin {
2072aa75114cSAlexander Motin 	struct icl_pdu *request;
2073aa75114cSAlexander Motin 	struct iscsi_bhs_task_management_request *bhstmr;
2074aa75114cSAlexander Motin 	struct ccb_abort *cab = &ccb->cab;
2075aa75114cSAlexander Motin 	struct iscsi_outstanding *io, *aio;
20767a03d007SEdward Tomasz Napierala 	uint32_t initiator_task_tag;
2077aa75114cSAlexander Motin 
2078aa75114cSAlexander Motin 	ISCSI_SESSION_LOCK_ASSERT(is);
2079aa75114cSAlexander Motin 
2080aa75114cSAlexander Motin #if 0
2081aa75114cSAlexander Motin 	KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2082aa75114cSAlexander Motin #else
2083aa75114cSAlexander Motin 	if (is->is_login_phase) {
2084aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_ABORTED;
2085aa75114cSAlexander Motin 		xpt_done(ccb);
2086aa75114cSAlexander Motin 		return;
2087aa75114cSAlexander Motin 	}
2088aa75114cSAlexander Motin #endif
2089aa75114cSAlexander Motin 
2090aa75114cSAlexander Motin 	aio = iscsi_outstanding_find_ccb(is, cab->abort_ccb);
2091aa75114cSAlexander Motin 	if (aio == NULL) {
2092aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_REQ_CMP;
2093aa75114cSAlexander Motin 		xpt_done(ccb);
2094aa75114cSAlexander Motin 		return;
2095aa75114cSAlexander Motin 	}
2096aa75114cSAlexander Motin 
2097d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
2098aa75114cSAlexander Motin 	if (request == NULL) {
2099aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
2100aa75114cSAlexander Motin 		xpt_done(ccb);
2101aa75114cSAlexander Motin 		return;
2102aa75114cSAlexander Motin 	}
2103aa75114cSAlexander Motin 
21047a03d007SEdward Tomasz Napierala 	initiator_task_tag = is->is_initiator_task_tag++;
2105aa75114cSAlexander Motin 
2106604c023fSEdward Tomasz Napierala 	io = iscsi_outstanding_add(is, request, NULL, &initiator_task_tag);
2107aa75114cSAlexander Motin 	if (io == NULL) {
2108aa75114cSAlexander Motin 		icl_pdu_free(request);
2109aa75114cSAlexander Motin 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
2110aa75114cSAlexander Motin 		xpt_done(ccb);
2111aa75114cSAlexander Motin 		return;
2112aa75114cSAlexander Motin 	}
2113aa75114cSAlexander Motin 	io->io_datasn = aio->io_initiator_task_tag;
21147a03d007SEdward Tomasz Napierala 
21157a03d007SEdward Tomasz Napierala 	bhstmr = (struct iscsi_bhs_task_management_request *)request->ip_bhs;
21167a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_opcode = ISCSI_BHS_OPCODE_TASK_REQUEST;
21177a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_function = 0x80 | BHSTMR_FUNCTION_ABORT_TASK;
21187a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_lun = htobe64(CAM_EXTLUN_BYTE_SWIZZLE(ccb->ccb_h.target_lun));
21197a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_initiator_task_tag = initiator_task_tag;
21207a03d007SEdward Tomasz Napierala 	bhstmr->bhstmr_referenced_task_tag = aio->io_initiator_task_tag;
21217a03d007SEdward Tomasz Napierala 
2122aa75114cSAlexander Motin 	iscsi_pdu_queue_locked(request);
2123aa75114cSAlexander Motin }
2124aa75114cSAlexander Motin 
2125aa75114cSAlexander Motin static void
2126009ea47eSEdward Tomasz Napierala iscsi_action_scsiio(struct iscsi_session *is, union ccb *ccb)
2127009ea47eSEdward Tomasz Napierala {
2128009ea47eSEdward Tomasz Napierala 	struct icl_pdu *request;
2129009ea47eSEdward Tomasz Napierala 	struct iscsi_bhs_scsi_command *bhssc;
2130009ea47eSEdward Tomasz Napierala 	struct ccb_scsiio *csio;
2131aa75114cSAlexander Motin 	struct iscsi_outstanding *io;
2132009ea47eSEdward Tomasz Napierala 	size_t len;
21337a03d007SEdward Tomasz Napierala 	uint32_t initiator_task_tag;
2134009ea47eSEdward Tomasz Napierala 	int error;
2135009ea47eSEdward Tomasz Napierala 
2136009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2137009ea47eSEdward Tomasz Napierala 
2138009ea47eSEdward Tomasz Napierala #if 0
2139009ea47eSEdward Tomasz Napierala 	KASSERT(is->is_login_phase == false, ("%s called during Login Phase", __func__));
2140009ea47eSEdward Tomasz Napierala #else
2141009ea47eSEdward Tomasz Napierala 	if (is->is_login_phase) {
2142009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "called during login phase");
2143009ea47eSEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2144009ea47eSEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
2145009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
2146009ea47eSEdward Tomasz Napierala 		}
2147009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_ABORTED | CAM_DEV_QFRZN;
2148009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2149009ea47eSEdward Tomasz Napierala 		return;
2150009ea47eSEdward Tomasz Napierala 	}
2151009ea47eSEdward Tomasz Napierala #endif
2152009ea47eSEdward Tomasz Napierala 
2153d2d52b00SEdward Tomasz Napierala 	request = icl_pdu_new(is->is_conn, M_NOWAIT);
2154009ea47eSEdward Tomasz Napierala 	if (request == NULL) {
2155009ea47eSEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2156009ea47eSEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
2157009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
2158009ea47eSEdward Tomasz Napierala 		}
2159009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
2160009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2161009ea47eSEdward Tomasz Napierala 		return;
2162009ea47eSEdward Tomasz Napierala 	}
2163009ea47eSEdward Tomasz Napierala 
21647a03d007SEdward Tomasz Napierala 	initiator_task_tag = is->is_initiator_task_tag++;
2165604c023fSEdward Tomasz Napierala 	io = iscsi_outstanding_add(is, request, ccb, &initiator_task_tag);
21667a03d007SEdward Tomasz Napierala 	if (io == NULL) {
21677a03d007SEdward Tomasz Napierala 		icl_pdu_free(request);
21687a03d007SEdward Tomasz Napierala 		if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
21697a03d007SEdward Tomasz Napierala 			xpt_freeze_devq(ccb->ccb_h.path, 1);
21707a03d007SEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "freezing devq");
21717a03d007SEdward Tomasz Napierala 		}
21727a03d007SEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
21737a03d007SEdward Tomasz Napierala 		xpt_done(ccb);
21747a03d007SEdward Tomasz Napierala 		return;
21757a03d007SEdward Tomasz Napierala 	}
21767a03d007SEdward Tomasz Napierala 
2177009ea47eSEdward Tomasz Napierala 	csio = &ccb->csio;
2178009ea47eSEdward Tomasz Napierala 	bhssc = (struct iscsi_bhs_scsi_command *)request->ip_bhs;
2179009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_opcode = ISCSI_BHS_OPCODE_SCSI_COMMAND;
2180009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_flags |= BHSSC_FLAGS_F;
2181009ea47eSEdward Tomasz Napierala 	switch (csio->ccb_h.flags & CAM_DIR_MASK) {
2182009ea47eSEdward Tomasz Napierala 	case CAM_DIR_IN:
2183009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_flags |= BHSSC_FLAGS_R;
2184009ea47eSEdward Tomasz Napierala 		break;
2185009ea47eSEdward Tomasz Napierala 	case CAM_DIR_OUT:
2186009ea47eSEdward Tomasz Napierala 		bhssc->bhssc_flags |= BHSSC_FLAGS_W;
2187009ea47eSEdward Tomasz Napierala 		break;
2188009ea47eSEdward Tomasz Napierala 	}
2189009ea47eSEdward Tomasz Napierala 
2190462cf3baSAlexander Motin 	if ((ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0) {
2191009ea47eSEdward Tomasz Napierala 		switch (csio->tag_action) {
2192009ea47eSEdward Tomasz Napierala 		case MSG_HEAD_OF_Q_TAG:
2193009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_HOQ;
2194009ea47eSEdward Tomasz Napierala 			break;
2195009ea47eSEdward Tomasz Napierala 		case MSG_ORDERED_Q_TAG:
2196009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_ORDERED;
2197009ea47eSEdward Tomasz Napierala 			break;
2198009ea47eSEdward Tomasz Napierala 		case MSG_ACA_TASK:
2199009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_ACA;
2200009ea47eSEdward Tomasz Napierala 			break;
2201009ea47eSEdward Tomasz Napierala 		case MSG_SIMPLE_Q_TAG:
2202009ea47eSEdward Tomasz Napierala 		default:
2203009ea47eSEdward Tomasz Napierala 			bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_SIMPLE;
2204009ea47eSEdward Tomasz Napierala 			break;
2205009ea47eSEdward Tomasz Napierala 		}
2206462cf3baSAlexander Motin 	} else
2207462cf3baSAlexander Motin 		bhssc->bhssc_flags |= BHSSC_FLAGS_ATTR_UNTAGGED;
2208009ea47eSEdward Tomasz Napierala 
2209a9f2f291SEdward Tomasz Napierala 	bhssc->bhssc_lun = htobe64(CAM_EXTLUN_BYTE_SWIZZLE(ccb->ccb_h.target_lun));
22107a03d007SEdward Tomasz Napierala 	bhssc->bhssc_initiator_task_tag = initiator_task_tag;
2211009ea47eSEdward Tomasz Napierala 	bhssc->bhssc_expected_data_transfer_length = htonl(csio->dxfer_len);
2212009ea47eSEdward Tomasz Napierala 	KASSERT(csio->cdb_len <= sizeof(bhssc->bhssc_cdb),
2213009ea47eSEdward Tomasz Napierala 	    ("unsupported CDB size %zd", (size_t)csio->cdb_len));
2214009ea47eSEdward Tomasz Napierala 
2215009ea47eSEdward Tomasz Napierala 	if (csio->ccb_h.flags & CAM_CDB_POINTER)
2216009ea47eSEdward Tomasz Napierala 		memcpy(&bhssc->bhssc_cdb, csio->cdb_io.cdb_ptr, csio->cdb_len);
2217009ea47eSEdward Tomasz Napierala 	else
2218009ea47eSEdward Tomasz Napierala 		memcpy(&bhssc->bhssc_cdb, csio->cdb_io.cdb_bytes, csio->cdb_len);
2219009ea47eSEdward Tomasz Napierala 
2220009ea47eSEdward Tomasz Napierala 	if (is->is_immediate_data &&
2221009ea47eSEdward Tomasz Napierala 	    (csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
2222009ea47eSEdward Tomasz Napierala 		len = csio->dxfer_len;
2223009ea47eSEdward Tomasz Napierala 		//ISCSI_SESSION_DEBUG(is, "adding %zd of immediate data", len);
2224009ea47eSEdward Tomasz Napierala 		if (len > is->is_first_burst_length) {
2225009ea47eSEdward Tomasz Napierala 			ISCSI_SESSION_DEBUG(is, "len %zd -> %zd", len, is->is_first_burst_length);
2226009ea47eSEdward Tomasz Napierala 			len = is->is_first_burst_length;
2227009ea47eSEdward Tomasz Napierala 		}
22283f9e1172SAlexander Motin 		if (len > is->is_max_data_segment_length) {
22293f9e1172SAlexander Motin 			ISCSI_SESSION_DEBUG(is, "len %zd -> %zd", len, is->is_max_data_segment_length);
22303f9e1172SAlexander Motin 			len = is->is_max_data_segment_length;
22313f9e1172SAlexander Motin 		}
2232009ea47eSEdward Tomasz Napierala 
2233009ea47eSEdward Tomasz Napierala 		error = icl_pdu_append_data(request, csio->data_ptr, len, M_NOWAIT);
2234009ea47eSEdward Tomasz Napierala 		if (error != 0) {
2235938bcb04SEdward Tomasz Napierala 			iscsi_outstanding_remove(is, io);
2236009ea47eSEdward Tomasz Napierala 			icl_pdu_free(request);
2237009ea47eSEdward Tomasz Napierala 			if ((ccb->ccb_h.status & CAM_DEV_QFRZN) == 0) {
2238009ea47eSEdward Tomasz Napierala 				xpt_freeze_devq(ccb->ccb_h.path, 1);
2239009ea47eSEdward Tomasz Napierala 				ISCSI_SESSION_DEBUG(is, "freezing devq");
2240009ea47eSEdward Tomasz Napierala 			}
2241009ea47eSEdward Tomasz Napierala 			ccb->ccb_h.status = CAM_RESRC_UNAVAIL | CAM_DEV_QFRZN;
2242009ea47eSEdward Tomasz Napierala 			xpt_done(ccb);
2243009ea47eSEdward Tomasz Napierala 			return;
2244009ea47eSEdward Tomasz Napierala 		}
2245009ea47eSEdward Tomasz Napierala 	}
2246009ea47eSEdward Tomasz Napierala 	iscsi_pdu_queue_locked(request);
2247009ea47eSEdward Tomasz Napierala }
2248009ea47eSEdward Tomasz Napierala 
2249009ea47eSEdward Tomasz Napierala static void
2250009ea47eSEdward Tomasz Napierala iscsi_action(struct cam_sim *sim, union ccb *ccb)
2251009ea47eSEdward Tomasz Napierala {
2252009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
2253009ea47eSEdward Tomasz Napierala 
2254009ea47eSEdward Tomasz Napierala 	is = cam_sim_softc(sim);
2255009ea47eSEdward Tomasz Napierala 
2256009ea47eSEdward Tomasz Napierala 	ISCSI_SESSION_LOCK_ASSERT(is);
2257009ea47eSEdward Tomasz Napierala 
2258f1f12e40SEdward Tomasz Napierala 	if (is->is_terminating ||
2259f1f12e40SEdward Tomasz Napierala 	    (is->is_connected == false && fail_on_disconnection)) {
2260009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_DEV_NOT_THERE;
2261009ea47eSEdward Tomasz Napierala 		xpt_done(ccb);
2262009ea47eSEdward Tomasz Napierala 		return;
2263009ea47eSEdward Tomasz Napierala 	}
2264009ea47eSEdward Tomasz Napierala 
2265009ea47eSEdward Tomasz Napierala 	switch (ccb->ccb_h.func_code) {
2266009ea47eSEdward Tomasz Napierala 	case XPT_PATH_INQ:
2267009ea47eSEdward Tomasz Napierala 	{
2268009ea47eSEdward Tomasz Napierala 		struct ccb_pathinq *cpi = &ccb->cpi;
2269009ea47eSEdward Tomasz Napierala 
2270009ea47eSEdward Tomasz Napierala 		cpi->version_num = 1;
2271009ea47eSEdward Tomasz Napierala 		cpi->hba_inquiry = PI_TAG_ABLE;
2272009ea47eSEdward Tomasz Napierala 		cpi->target_sprt = 0;
2273a9f2f291SEdward Tomasz Napierala 		cpi->hba_misc = PIM_EXTLUNS;
2274009ea47eSEdward Tomasz Napierala 		cpi->hba_eng_cnt = 0;
2275009ea47eSEdward Tomasz Napierala 		cpi->max_target = 0;
227617cf3eb1SEdward Tomasz Napierala 		/*
227717cf3eb1SEdward Tomasz Napierala 		 * Note that the variable below is only relevant for targets
227817cf3eb1SEdward Tomasz Napierala 		 * that don't claim compliance with anything above SPC2, which
227917cf3eb1SEdward Tomasz Napierala 		 * means they don't support REPORT_LUNS.
228017cf3eb1SEdward Tomasz Napierala 		 */
228117cf3eb1SEdward Tomasz Napierala 		cpi->max_lun = 255;
2282a9f2f291SEdward Tomasz Napierala 		cpi->initiator_id = ~0;
22837843bd03SEdward Tomasz Napierala 		strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
22847843bd03SEdward Tomasz Napierala 		strlcpy(cpi->hba_vid, "iSCSI", HBA_IDLEN);
22857843bd03SEdward Tomasz Napierala 		strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
2286009ea47eSEdward Tomasz Napierala 		cpi->unit_number = cam_sim_unit(sim);
2287009ea47eSEdward Tomasz Napierala 		cpi->bus_id = cam_sim_bus(sim);
2288009ea47eSEdward Tomasz Napierala 		cpi->base_transfer_speed = 150000; /* XXX */
2289009ea47eSEdward Tomasz Napierala 		cpi->transport = XPORT_ISCSI;
2290009ea47eSEdward Tomasz Napierala 		cpi->transport_version = 0;
2291009ea47eSEdward Tomasz Napierala 		cpi->protocol = PROTO_SCSI;
2292009ea47eSEdward Tomasz Napierala 		cpi->protocol_version = SCSI_REV_SPC3;
2293009ea47eSEdward Tomasz Napierala 		cpi->maxio = MAXPHYS;
2294009ea47eSEdward Tomasz Napierala 		cpi->ccb_h.status = CAM_REQ_CMP;
2295009ea47eSEdward Tomasz Napierala 		break;
2296009ea47eSEdward Tomasz Napierala 	}
2297462cf3baSAlexander Motin 	case XPT_GET_TRAN_SETTINGS:
2298462cf3baSAlexander Motin 	{
2299462cf3baSAlexander Motin 		struct ccb_trans_settings	*cts;
2300462cf3baSAlexander Motin 		struct ccb_trans_settings_scsi	*scsi;
2301462cf3baSAlexander Motin 
2302462cf3baSAlexander Motin 		cts = &ccb->cts;
2303462cf3baSAlexander Motin 		scsi = &cts->proto_specific.scsi;
2304462cf3baSAlexander Motin 
2305462cf3baSAlexander Motin 		cts->protocol = PROTO_SCSI;
2306462cf3baSAlexander Motin 		cts->protocol_version = SCSI_REV_SPC3;
2307462cf3baSAlexander Motin 		cts->transport = XPORT_ISCSI;
2308462cf3baSAlexander Motin 		cts->transport_version = 0;
2309462cf3baSAlexander Motin 		scsi->valid = CTS_SCSI_VALID_TQ;
2310462cf3baSAlexander Motin 		scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
2311462cf3baSAlexander Motin 		cts->ccb_h.status = CAM_REQ_CMP;
2312462cf3baSAlexander Motin 		break;
2313462cf3baSAlexander Motin 	}
2314009ea47eSEdward Tomasz Napierala 	case XPT_CALC_GEOMETRY:
2315009ea47eSEdward Tomasz Napierala 		cam_calc_geometry(&ccb->ccg, /*extended*/1);
2316009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_CMP;
2317009ea47eSEdward Tomasz Napierala 		break;
2318009ea47eSEdward Tomasz Napierala #if 0
2319009ea47eSEdward Tomasz Napierala 	/*
2320009ea47eSEdward Tomasz Napierala 	 * XXX: What's the point?
2321009ea47eSEdward Tomasz Napierala 	 */
2322009ea47eSEdward Tomasz Napierala 	case XPT_RESET_BUS:
2323009ea47eSEdward Tomasz Napierala 	case XPT_TERM_IO:
2324009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "faking success for reset, abort, or term_io");
2325009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_REQ_CMP;
2326009ea47eSEdward Tomasz Napierala 		break;
2327009ea47eSEdward Tomasz Napierala #endif
2328aa75114cSAlexander Motin 	case XPT_ABORT:
2329aa75114cSAlexander Motin 		iscsi_action_abort(is, ccb);
2330aa75114cSAlexander Motin 		return;
2331009ea47eSEdward Tomasz Napierala 	case XPT_SCSI_IO:
2332009ea47eSEdward Tomasz Napierala 		iscsi_action_scsiio(is, ccb);
2333009ea47eSEdward Tomasz Napierala 		return;
2334009ea47eSEdward Tomasz Napierala 	default:
2335009ea47eSEdward Tomasz Napierala #if 0
2336009ea47eSEdward Tomasz Napierala 		ISCSI_SESSION_DEBUG(is, "got unsupported code 0x%x", ccb->ccb_h.func_code);
2337009ea47eSEdward Tomasz Napierala #endif
2338009ea47eSEdward Tomasz Napierala 		ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
2339009ea47eSEdward Tomasz Napierala 		break;
2340009ea47eSEdward Tomasz Napierala 	}
2341009ea47eSEdward Tomasz Napierala 	xpt_done(ccb);
2342009ea47eSEdward Tomasz Napierala }
2343009ea47eSEdward Tomasz Napierala 
2344009ea47eSEdward Tomasz Napierala static void
2345009ea47eSEdward Tomasz Napierala iscsi_poll(struct cam_sim *sim)
2346009ea47eSEdward Tomasz Napierala {
2347009ea47eSEdward Tomasz Napierala 
2348009ea47eSEdward Tomasz Napierala 	KASSERT(0, ("%s: you're not supposed to be here", __func__));
2349009ea47eSEdward Tomasz Napierala }
2350009ea47eSEdward Tomasz Napierala 
2351009ea47eSEdward Tomasz Napierala static void
2352481b36c6SSteven Hartland iscsi_terminate_sessions(struct iscsi_softc *sc)
2353009ea47eSEdward Tomasz Napierala {
2354009ea47eSEdward Tomasz Napierala 	struct iscsi_session *is;
2355009ea47eSEdward Tomasz Napierala 
2356481b36c6SSteven Hartland 	sx_slock(&sc->sc_lock);
2357481b36c6SSteven Hartland 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next)
2358481b36c6SSteven Hartland 		iscsi_session_terminate(is);
2359481b36c6SSteven Hartland 	while(!TAILQ_EMPTY(&sc->sc_sessions)) {
2360481b36c6SSteven Hartland 		ISCSI_DEBUG("waiting for sessions to terminate");
2361481b36c6SSteven Hartland 		cv_wait(&sc->sc_cv, &sc->sc_lock);
2362481b36c6SSteven Hartland 	}
2363481b36c6SSteven Hartland 	ISCSI_DEBUG("all sessions terminated");
2364481b36c6SSteven Hartland 	sx_sunlock(&sc->sc_lock);
2365481b36c6SSteven Hartland }
2366481b36c6SSteven Hartland 
2367481b36c6SSteven Hartland static void
2368481b36c6SSteven Hartland iscsi_shutdown_pre(struct iscsi_softc *sc)
2369481b36c6SSteven Hartland {
2370481b36c6SSteven Hartland 	struct iscsi_session *is;
2371481b36c6SSteven Hartland 
2372481b36c6SSteven Hartland 	if (!fail_on_shutdown)
2373481b36c6SSteven Hartland 		return;
2374009ea47eSEdward Tomasz Napierala 
2375e553ca49SEdward Tomasz Napierala 	/*
2376e553ca49SEdward Tomasz Napierala 	 * If we have any sessions waiting for reconnection, request
2377e553ca49SEdward Tomasz Napierala 	 * maintenance thread to fail them immediately instead of waiting
2378e553ca49SEdward Tomasz Napierala 	 * for reconnect timeout.
2379481b36c6SSteven Hartland 	 *
2380481b36c6SSteven Hartland 	 * This prevents LUNs with mounted filesystems that are supported
2381481b36c6SSteven Hartland 	 * by disconnected iSCSI sessions from hanging, however it will
2382481b36c6SSteven Hartland 	 * fail all queued BIOs.
2383e553ca49SEdward Tomasz Napierala 	 */
2384481b36c6SSteven Hartland 	ISCSI_DEBUG("forcing failing all disconnected sessions due to shutdown");
2385481b36c6SSteven Hartland 
2386481b36c6SSteven Hartland 	fail_on_disconnection = 1;
2387481b36c6SSteven Hartland 
2388009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
2389e553ca49SEdward Tomasz Napierala 	TAILQ_FOREACH(is, &sc->sc_sessions, is_next) {
2390e553ca49SEdward Tomasz Napierala 		ISCSI_SESSION_LOCK(is);
2391481b36c6SSteven Hartland 		if (!is->is_connected) {
2392481b36c6SSteven Hartland 			ISCSI_SESSION_DEBUG(is, "force failing disconnected session early");
2393e553ca49SEdward Tomasz Napierala 			iscsi_session_reconnect(is);
2394481b36c6SSteven Hartland 		}
2395e553ca49SEdward Tomasz Napierala 		ISCSI_SESSION_UNLOCK(is);
2396e553ca49SEdward Tomasz Napierala 	}
2397009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
2398009ea47eSEdward Tomasz Napierala }
2399009ea47eSEdward Tomasz Napierala 
2400481b36c6SSteven Hartland static void
2401481b36c6SSteven Hartland iscsi_shutdown_post(struct iscsi_softc *sc)
2402481b36c6SSteven Hartland {
2403481b36c6SSteven Hartland 
2404481b36c6SSteven Hartland 	ISCSI_DEBUG("removing all sessions due to shutdown");
2405481b36c6SSteven Hartland 	iscsi_terminate_sessions(sc);
2406481b36c6SSteven Hartland }
2407481b36c6SSteven Hartland 
2408009ea47eSEdward Tomasz Napierala static int
2409009ea47eSEdward Tomasz Napierala iscsi_load(void)
2410009ea47eSEdward Tomasz Napierala {
2411009ea47eSEdward Tomasz Napierala 	int error;
2412009ea47eSEdward Tomasz Napierala 
2413009ea47eSEdward Tomasz Napierala 	sc = malloc(sizeof(*sc), M_ISCSI, M_ZERO | M_WAITOK);
2414009ea47eSEdward Tomasz Napierala 	sx_init(&sc->sc_lock, "iscsi");
2415009ea47eSEdward Tomasz Napierala 	TAILQ_INIT(&sc->sc_sessions);
2416009ea47eSEdward Tomasz Napierala 	cv_init(&sc->sc_cv, "iscsi_cv");
2417009ea47eSEdward Tomasz Napierala 
2418009ea47eSEdward Tomasz Napierala 	iscsi_outstanding_zone = uma_zcreate("iscsi_outstanding",
2419009ea47eSEdward Tomasz Napierala 	    sizeof(struct iscsi_outstanding), NULL, NULL, NULL, NULL,
2420c28c09c1SEdward Tomasz Napierala 	    UMA_ALIGN_PTR, 0);
2421009ea47eSEdward Tomasz Napierala 
2422009ea47eSEdward Tomasz Napierala 	error = make_dev_p(MAKEDEV_CHECKNAME, &sc->sc_cdev, &iscsi_cdevsw,
2423009ea47eSEdward Tomasz Napierala 	    NULL, UID_ROOT, GID_WHEEL, 0600, "iscsi");
2424009ea47eSEdward Tomasz Napierala 	if (error != 0) {
2425009ea47eSEdward Tomasz Napierala 		ISCSI_WARN("failed to create device node, error %d", error);
2426009ea47eSEdward Tomasz Napierala 		return (error);
2427009ea47eSEdward Tomasz Napierala 	}
2428009ea47eSEdward Tomasz Napierala 	sc->sc_cdev->si_drv1 = sc;
2429009ea47eSEdward Tomasz Napierala 
2430481b36c6SSteven Hartland 	sc->sc_shutdown_pre_eh = EVENTHANDLER_REGISTER(shutdown_pre_sync,
2431481b36c6SSteven Hartland 	    iscsi_shutdown_pre, sc, SHUTDOWN_PRI_FIRST);
2432481b36c6SSteven Hartland 	/*
2433481b36c6SSteven Hartland 	 * shutdown_post_sync needs to run after filesystem shutdown and before
2434481b36c6SSteven Hartland 	 * CAM shutdown - otherwise when rebooting with an iSCSI session that is
2435481b36c6SSteven Hartland 	 * disconnected but has outstanding requests, dashutdown() will hang on
2436481b36c6SSteven Hartland 	 * cam_periph_runccb().
2437481b36c6SSteven Hartland 	 */
2438481b36c6SSteven Hartland 	sc->sc_shutdown_post_eh = EVENTHANDLER_REGISTER(shutdown_post_sync,
2439481b36c6SSteven Hartland 	    iscsi_shutdown_post, sc, SHUTDOWN_PRI_DEFAULT - 1);
2440009ea47eSEdward Tomasz Napierala 
2441009ea47eSEdward Tomasz Napierala 	return (0);
2442009ea47eSEdward Tomasz Napierala }
2443009ea47eSEdward Tomasz Napierala 
2444009ea47eSEdward Tomasz Napierala static int
2445009ea47eSEdward Tomasz Napierala iscsi_unload(void)
2446009ea47eSEdward Tomasz Napierala {
2447009ea47eSEdward Tomasz Napierala 
2448a667cf73SEdward Tomasz Napierala 	if (sc->sc_cdev != NULL) {
2449009ea47eSEdward Tomasz Napierala 		ISCSI_DEBUG("removing device node");
2450009ea47eSEdward Tomasz Napierala 		destroy_dev(sc->sc_cdev);
2451009ea47eSEdward Tomasz Napierala 		ISCSI_DEBUG("device node removed");
2452a667cf73SEdward Tomasz Napierala 	}
2453009ea47eSEdward Tomasz Napierala 
2454481b36c6SSteven Hartland 	if (sc->sc_shutdown_pre_eh != NULL)
2455481b36c6SSteven Hartland 		EVENTHANDLER_DEREGISTER(shutdown_pre_sync, sc->sc_shutdown_pre_eh);
2456481b36c6SSteven Hartland 	if (sc->sc_shutdown_post_eh != NULL)
2457481b36c6SSteven Hartland 		EVENTHANDLER_DEREGISTER(shutdown_post_sync, sc->sc_shutdown_post_eh);
2458009ea47eSEdward Tomasz Napierala 
2459481b36c6SSteven Hartland 	iscsi_terminate_sessions(sc);
2460009ea47eSEdward Tomasz Napierala 
2461009ea47eSEdward Tomasz Napierala 	uma_zdestroy(iscsi_outstanding_zone);
2462009ea47eSEdward Tomasz Napierala 	sx_destroy(&sc->sc_lock);
2463009ea47eSEdward Tomasz Napierala 	cv_destroy(&sc->sc_cv);
2464009ea47eSEdward Tomasz Napierala 	free(sc, M_ISCSI);
2465009ea47eSEdward Tomasz Napierala 	return (0);
2466009ea47eSEdward Tomasz Napierala }
2467009ea47eSEdward Tomasz Napierala 
2468009ea47eSEdward Tomasz Napierala static int
2469009ea47eSEdward Tomasz Napierala iscsi_quiesce(void)
2470009ea47eSEdward Tomasz Napierala {
2471009ea47eSEdward Tomasz Napierala 	sx_slock(&sc->sc_lock);
2472009ea47eSEdward Tomasz Napierala 	if (!TAILQ_EMPTY(&sc->sc_sessions)) {
2473009ea47eSEdward Tomasz Napierala 		sx_sunlock(&sc->sc_lock);
2474009ea47eSEdward Tomasz Napierala 		return (EBUSY);
2475009ea47eSEdward Tomasz Napierala 	}
2476009ea47eSEdward Tomasz Napierala 	sx_sunlock(&sc->sc_lock);
2477009ea47eSEdward Tomasz Napierala 	return (0);
2478009ea47eSEdward Tomasz Napierala }
2479009ea47eSEdward Tomasz Napierala 
2480009ea47eSEdward Tomasz Napierala static int
2481009ea47eSEdward Tomasz Napierala iscsi_modevent(module_t mod, int what, void *arg)
2482009ea47eSEdward Tomasz Napierala {
2483009ea47eSEdward Tomasz Napierala 	int error;
2484009ea47eSEdward Tomasz Napierala 
2485009ea47eSEdward Tomasz Napierala 	switch (what) {
2486009ea47eSEdward Tomasz Napierala 	case MOD_LOAD:
2487009ea47eSEdward Tomasz Napierala 		error = iscsi_load();
2488009ea47eSEdward Tomasz Napierala 		break;
2489009ea47eSEdward Tomasz Napierala 	case MOD_UNLOAD:
2490009ea47eSEdward Tomasz Napierala 		error = iscsi_unload();
2491009ea47eSEdward Tomasz Napierala 		break;
2492009ea47eSEdward Tomasz Napierala 	case MOD_QUIESCE:
2493009ea47eSEdward Tomasz Napierala 		error = iscsi_quiesce();
2494009ea47eSEdward Tomasz Napierala 		break;
2495009ea47eSEdward Tomasz Napierala 	default:
2496009ea47eSEdward Tomasz Napierala 		error = EINVAL;
2497009ea47eSEdward Tomasz Napierala 		break;
2498009ea47eSEdward Tomasz Napierala 	}
2499009ea47eSEdward Tomasz Napierala 	return (error);
2500009ea47eSEdward Tomasz Napierala }
2501009ea47eSEdward Tomasz Napierala 
2502009ea47eSEdward Tomasz Napierala moduledata_t iscsi_data = {
2503009ea47eSEdward Tomasz Napierala 	"iscsi",
2504009ea47eSEdward Tomasz Napierala 	iscsi_modevent,
2505009ea47eSEdward Tomasz Napierala 	0
2506009ea47eSEdward Tomasz Napierala };
2507009ea47eSEdward Tomasz Napierala 
2508009ea47eSEdward Tomasz Napierala DECLARE_MODULE(iscsi, iscsi_data, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
2509009ea47eSEdward Tomasz Napierala MODULE_DEPEND(iscsi, cam, 1, 1, 1);
2510009ea47eSEdward Tomasz Napierala MODULE_DEPEND(iscsi, icl, 1, 1, 1);
2511