<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -223,12 +223,35 @@ config SCSI_FC_ATTRS
 
 config SCSI_ISCSI_ATTRS
 	tristate "iSCSI Transport Attributes"
-	depends on SCSI
+	depends on SCSI &amp;&amp; NET
 	help
 	  If you wish to export transport-specific information about
 	  each attached iSCSI device to sysfs, say Y.
 	  Otherwise, say N.
 
+config ISCSI_TCP
+	tristate "iSCSI Initiator over TCP/IP"
+	depends on SCSI &amp;&amp; INET &amp;&amp; SCSI_ISCSI_ATTRS
+	select CRYPTO
+	select CRYPTO_MD5
+	select CRYPTO_CRC32C
+	help
+	 The iSCSI Driver provides a host with the ability to access storage
+	 through an IP network. The driver uses the iSCSI protocol to transport
+	 SCSI requests and responses over a TCP/IP network between the host
+	 (the "initiator") and "targets".  Architecturally, the iSCSI driver
+	 combines with the host's TCP/IP stack, network drivers, and Network
+	 Interface Card (NIC) to provide the same functions as a SCSI or a
+	 Fibre Channel (FC) adapter driver with a Host Bus Adapter (HBA).
+
+	 To compile this driver as a module, choose M here: the
+	 module will be called iscsi_tcp.
+
+	 The userspace component needed to initialize the driver, documentation,
+	 and sample configuration files can be found here:
+
+	 http://linux-iscsi.sf.net
+
 endmenu
 
 menu "SCSI low-level drivers"
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -30,6 +30,7 @@ obj-$(CONFIG_SCSI_SPI_ATTRS)	+= scsi_tra
 obj-$(CONFIG_SCSI_FC_ATTRS) 	+= scsi_transport_fc.o
 obj-$(CONFIG_SCSI_ISCSI_ATTRS)	+= scsi_transport_iscsi.o
 
+obj-$(CONFIG_ISCSI_TCP) 	+= iscsi_tcp.o
 obj-$(CONFIG_SCSI_AMIGA7XX)	+= amiga7xx.o	53c7xx.o
 obj-$(CONFIG_A3000_SCSI)	+= a3000.o	wd33c93.o
 obj-$(CONFIG_A2091_SCSI)	+= a2091.o	wd33c93.o
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
new file mode 100644
--- /dev/null
+++ b/drivers/scsi/iscsi_tcp.c
@@ -0,0 +1,3627 @@
+/*
+ * iSCSI Initiator over TCP/IP Data-Path
+ *
+ * Copyright (C) 2004 Dmitry Yusupov
+ * Copyright (C) 2004 Alex Aizman
+ * Copyright (C) 2005 Mike Christie
+ * maintained by open-iscsi@googlegroups.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * See the file COPYING included with this distribution for more details.
+ *
+ * Credits:
+ *	Christoph Hellwig
+ *	FUJITA Tomonori
+ *	Arne Redlich
+ *	Zhenyu Wang
+ */
+
+#include &lt;linux/types.h&gt;
+#include &lt;linux/list.h&gt;
+#include &lt;linux/inet.h&gt;
+#include &lt;linux/blkdev.h&gt;
+#include &lt;linux/crypto.h&gt;
+#include &lt;linux/delay.h&gt;
+#include &lt;linux/kfifo.h&gt;
+#include &lt;linux/scatterlist.h&gt;
+#include &lt;net/tcp.h&gt;
+#include &lt;scsi/scsi_cmnd.h&gt;
+#include &lt;scsi/scsi_device.h&gt;
+#include &lt;scsi/scsi_eh.h&gt;
+#include &lt;scsi/scsi_request.h&gt;
+#include &lt;scsi/scsi_tcq.h&gt;
+#include &lt;scsi/scsi_host.h&gt;
+#include &lt;scsi/scsi.h&gt;
+#include &lt;scsi/scsi_transport_iscsi.h&gt;
+
+#include "iscsi_tcp.h"
+
+MODULE_AUTHOR("Dmitry Yusupov &lt;dmitry_yus@yahoo.com&gt;, "
+	      "Alex Aizman &lt;itn780@yahoo.com&gt;");
+MODULE_DESCRIPTION("iSCSI/TCP data-path");
+MODULE_LICENSE("GPL");
+
+/* #define DEBUG_TCP */
+/* #define DEBUG_SCSI */
+#define DEBUG_ASSERT
+
+#ifdef DEBUG_TCP
+#define debug_tcp(fmt...) printk(KERN_DEBUG "tcp: " fmt)
+#else
+#define debug_tcp(fmt...)
+#endif
+
+#ifdef DEBUG_SCSI
+#define debug_scsi(fmt...) printk(KERN_DEBUG "scsi: " fmt)
+#else
+#define debug_scsi(fmt...)
+#endif
+
+#ifndef DEBUG_ASSERT
+#ifdef BUG_ON
+#undef BUG_ON
+#endif
+#define BUG_ON(expr)
+#endif
+
+#define INVALID_SN_DELTA	0xffff
+
+static unsigned int iscsi_max_lun = 512;
+module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);
+
+/* global data */
+static kmem_cache_t *taskcache;
+
+static inline void
+iscsi_buf_init_virt(struct iscsi_buf *ibuf, char *vbuf, int size)
+{
+	sg_init_one(&amp;ibuf-&gt;sg, (u8 *)vbuf, size);
+	ibuf-&gt;sent = 0;
+}
+
+static inline void
+iscsi_buf_init_iov(struct iscsi_buf *ibuf, char *vbuf, int size)
+{
+	ibuf-&gt;sg.page = (void*)vbuf;
+	ibuf-&gt;sg.offset = (unsigned int)-1;
+	ibuf-&gt;sg.length = size;
+	ibuf-&gt;sent = 0;
+}
+
+static inline void*
+iscsi_buf_iov_base(struct iscsi_buf *ibuf)
+{
+	return (char*)ibuf-&gt;sg.page + ibuf-&gt;sent;
+}
+
+static inline void
+iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg)
+{
+	/*
+	 * Fastpath: sg element fits into single page
+	 */
+	if (sg-&gt;length + sg-&gt;offset &lt;= PAGE_SIZE &amp;&amp; page_count(sg-&gt;page) &gt;= 2) {
+		ibuf-&gt;sg.page = sg-&gt;page;
+		ibuf-&gt;sg.offset = sg-&gt;offset;
+		ibuf-&gt;sg.length = sg-&gt;length;
+	} else
+		iscsi_buf_init_iov(ibuf, page_address(sg-&gt;page), sg-&gt;length);
+	ibuf-&gt;sent = 0;
+}
+
+static inline int
+iscsi_buf_left(struct iscsi_buf *ibuf)
+{
+	int rc;
+
+	rc = ibuf-&gt;sg.length - ibuf-&gt;sent;
+	BUG_ON(rc &lt; 0);
+	return rc;
+}
+
+static inline void
+iscsi_buf_init_hdr(struct iscsi_conn *conn, struct iscsi_buf *ibuf,
+		   char *vbuf, u8 *crc)
+{
+	iscsi_buf_init_virt(ibuf, vbuf, sizeof(struct iscsi_hdr));
+	if (conn-&gt;hdrdgst_en) {
+		crypto_digest_digest(conn-&gt;tx_tfm, &amp;ibuf-&gt;sg, 1, crc);
+		ibuf-&gt;sg.length += sizeof(uint32_t);
+	}
+}
+
+static void
+iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
+{
+	struct iscsi_session *session = conn-&gt;session;
+	unsigned long flags;
+
+	spin_lock_irqsave(&amp;session-&gt;lock, flags);
+	if (session-&gt;conn_cnt == 1 || session-&gt;leadconn == conn)
+		session-&gt;state = ISCSI_STATE_FAILED;
+	spin_unlock_irqrestore(&amp;session-&gt;lock, flags);
+	set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+	set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_rx);
+	iscsi_conn_error(iscsi_handle(conn), err);
+}
+
+static inline int
+iscsi_check_assign_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr)
+{
+	uint32_t max_cmdsn = be32_to_cpu(hdr-&gt;max_cmdsn);
+	uint32_t exp_cmdsn = be32_to_cpu(hdr-&gt;exp_cmdsn);
+
+	if (max_cmdsn &lt; exp_cmdsn -1 &amp;&amp;
+	    max_cmdsn &gt; exp_cmdsn - INVALID_SN_DELTA)
+		return ISCSI_ERR_MAX_CMDSN;
+	if (max_cmdsn &gt; session-&gt;max_cmdsn ||
+	    max_cmdsn &lt; session-&gt;max_cmdsn - INVALID_SN_DELTA)
+		session-&gt;max_cmdsn = max_cmdsn;
+	if (exp_cmdsn &gt; session-&gt;exp_cmdsn ||
+	    exp_cmdsn &lt; session-&gt;exp_cmdsn - INVALID_SN_DELTA)
+		session-&gt;exp_cmdsn = exp_cmdsn;
+
+	return 0;
+}
+
+static inline int
+iscsi_hdr_extract(struct iscsi_conn *conn)
+{
+	struct sk_buff *skb = conn-&gt;in.skb;
+
+	if (conn-&gt;in.copy &gt;= conn-&gt;hdr_size &amp;&amp;
+	    conn-&gt;in_progress == IN_PROGRESS_WAIT_HEADER) {
+		/*
+		 * Zero-copy PDU Header: using connection context
+		 * to store header pointer.
+		 */
+		if (skb_shinfo(skb)-&gt;frag_list == NULL &amp;&amp;
+		    !skb_shinfo(skb)-&gt;nr_frags)
+			conn-&gt;in.hdr = (struct iscsi_hdr *)
+				((char*)skb-&gt;data + conn-&gt;in.offset);
+		else {
+			/* ignoring return code since we checked
+			 * in.copy before */
+			skb_copy_bits(skb, conn-&gt;in.offset,
+				&amp;conn-&gt;hdr, conn-&gt;hdr_size);
+			conn-&gt;in.hdr = &amp;conn-&gt;hdr;
+		}
+		conn-&gt;in.offset += conn-&gt;hdr_size;
+		conn-&gt;in.copy -= conn-&gt;hdr_size;
+	} else {
+		int hdr_remains;
+		int copylen;
+
+		/*
+		 * PDU header scattered across SKB's,
+		 * copying it... This'll happen quite rarely.
+		 */
+
+		if (conn-&gt;in_progress == IN_PROGRESS_WAIT_HEADER)
+			conn-&gt;in.hdr_offset = 0;
+
+		hdr_remains = conn-&gt;hdr_size - conn-&gt;in.hdr_offset;
+		BUG_ON(hdr_remains &lt;= 0);
+
+		copylen = min(conn-&gt;in.copy, hdr_remains);
+		skb_copy_bits(skb, conn-&gt;in.offset,
+			(char*)&amp;conn-&gt;hdr + conn-&gt;in.hdr_offset, copylen);
+
+		debug_tcp("PDU gather offset %d bytes %d in.offset %d "
+		       "in.copy %d\n", conn-&gt;in.hdr_offset, copylen,
+		       conn-&gt;in.offset, conn-&gt;in.copy);
+
+		conn-&gt;in.offset += copylen;
+		conn-&gt;in.copy -= copylen;
+		if (copylen &lt; hdr_remains)  {
+			conn-&gt;in_progress = IN_PROGRESS_HEADER_GATHER;
+			conn-&gt;in.hdr_offset += copylen;
+		        return -EAGAIN;
+		}
+		conn-&gt;in.hdr = &amp;conn-&gt;hdr;
+		conn-&gt;discontiguous_hdr_cnt++;
+	        conn-&gt;in_progress = IN_PROGRESS_WAIT_HEADER;
+	}
+
+	return 0;
+}
+
+static inline void
+iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct scsi_cmnd *sc = ctask-&gt;sc;
+	struct iscsi_session *session = conn-&gt;session;
+
+	spin_lock(&amp;session-&gt;lock);
+	if (unlikely(!sc)) {
+		spin_unlock(&amp;session-&gt;lock);
+		return;
+	}
+	if (sc-&gt;sc_data_direction == DMA_TO_DEVICE) {
+		struct iscsi_data_task *dtask, *n;
+		/* WRITE: cleanup Data-Out's if any */
+		spin_lock(&amp;conn-&gt;lock);
+		list_for_each_entry_safe(dtask, n, &amp;ctask-&gt;dataqueue, item) {
+			list_del(&amp;dtask-&gt;item);
+			mempool_free(dtask, ctask-&gt;datapool);
+		}
+		spin_unlock(&amp;conn-&gt;lock);
+	}
+	ctask-&gt;xmstate = XMSTATE_IDLE;
+	ctask-&gt;r2t = NULL;
+	ctask-&gt;sc = NULL;
+	__kfifo_put(session-&gt;cmdpool.queue, (void*)&amp;ctask, sizeof(void*));
+	spin_unlock(&amp;session-&gt;lock);
+}
+
+/**
+ * iscsi_cmd_rsp - SCSI Command Response processing
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ **/
+static int
+iscsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	int rc;
+	struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)conn-&gt;in.hdr;
+	struct iscsi_session *session = conn-&gt;session;
+	struct scsi_cmnd *sc = ctask-&gt;sc;
+
+	rc = iscsi_check_assign_cmdsn(session, (struct iscsi_nopin*)rhdr);
+	if (rc) {
+		sc-&gt;result = (DID_ERROR &lt;&lt; 16);
+		goto out;
+	}
+
+	conn-&gt;exp_statsn = be32_to_cpu(rhdr-&gt;statsn) + 1;
+
+	sc-&gt;result = (DID_OK &lt;&lt; 16) | rhdr-&gt;cmd_status;
+
+	if (rhdr-&gt;response != ISCSI_STATUS_CMD_COMPLETED) {
+		sc-&gt;result = (DID_ERROR &lt;&lt; 16);
+		goto out;
+	}
+
+	if (rhdr-&gt;cmd_status == SAM_STAT_CHECK_CONDITION &amp;&amp; conn-&gt;senselen) {
+		int sensecopy = min(conn-&gt;senselen, SCSI_SENSE_BUFFERSIZE);
+
+		memcpy(sc-&gt;sense_buffer, conn-&gt;data + 2, sensecopy);
+		debug_scsi("copied %d bytes of sense\n", sensecopy);
+	}
+
+	if (sc-&gt;sc_data_direction == DMA_TO_DEVICE)
+		goto out;
+
+	if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_UNDERFLOW) {
+		int res_count = be32_to_cpu(rhdr-&gt;residual_count);
+
+		if (res_count &gt; 0 &amp;&amp; res_count &lt;= sc-&gt;request_bufflen)
+			sc-&gt;resid = res_count;
+		else
+			sc-&gt;result = (DID_BAD_TARGET &lt;&lt; 16) | rhdr-&gt;cmd_status;
+	} else if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_BIDI_UNDERFLOW)
+		sc-&gt;result = (DID_BAD_TARGET &lt;&lt; 16) | rhdr-&gt;cmd_status;
+	else if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_OVERFLOW)
+		sc-&gt;resid = be32_to_cpu(rhdr-&gt;residual_count);
+
+out:
+	debug_scsi("done [sc %lx res %d itt 0x%x]\n",
+		   (long)sc, sc-&gt;result, ctask-&gt;itt);
+	conn-&gt;scsirsp_pdus_cnt++;
+	iscsi_ctask_cleanup(conn, ctask);
+	sc-&gt;scsi_done(sc);
+	return rc;
+}
+
+/**
+ * iscsi_data_rsp - SCSI Data-In Response processing
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ **/
+static int
+iscsi_data_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	int rc;
+	struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)conn-&gt;in.hdr;
+	struct iscsi_session *session = conn-&gt;session;
+	int datasn = be32_to_cpu(rhdr-&gt;datasn);
+
+	rc = iscsi_check_assign_cmdsn(session, (struct iscsi_nopin*)rhdr);
+	if (rc)
+		return rc;
+	/*
+	 * setup Data-In byte counter (gets decremented..)
+	 */
+	ctask-&gt;data_count = conn-&gt;in.datalen;
+
+	if (conn-&gt;in.datalen == 0)
+		return 0;
+
+	if (ctask-&gt;datasn != datasn)
+		return ISCSI_ERR_DATASN;
+
+	ctask-&gt;datasn++;
+
+	ctask-&gt;data_offset = be32_to_cpu(rhdr-&gt;offset);
+	if (ctask-&gt;data_offset + conn-&gt;in.datalen &gt; ctask-&gt;total_length)
+		return ISCSI_ERR_DATA_OFFSET;
+
+	if (rhdr-&gt;flags &amp; ISCSI_FLAG_DATA_STATUS) {
+		struct scsi_cmnd *sc = ctask-&gt;sc;
+
+		conn-&gt;exp_statsn = be32_to_cpu(rhdr-&gt;statsn) + 1;
+		if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_UNDERFLOW) {
+			int res_count = be32_to_cpu(rhdr-&gt;residual_count);
+
+			if (res_count &gt; 0 &amp;&amp;
+			    res_count &lt;= sc-&gt;request_bufflen) {
+				sc-&gt;resid = res_count;
+				sc-&gt;result = (DID_OK &lt;&lt; 16) | rhdr-&gt;cmd_status;
+			} else
+				sc-&gt;result = (DID_BAD_TARGET &lt;&lt; 16) |
+					rhdr-&gt;cmd_status;
+		} else if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_BIDI_UNDERFLOW)
+			sc-&gt;result = (DID_BAD_TARGET &lt;&lt; 16) | rhdr-&gt;cmd_status;
+		else if (rhdr-&gt;flags &amp; ISCSI_FLAG_CMD_OVERFLOW) {
+			sc-&gt;resid = be32_to_cpu(rhdr-&gt;residual_count);
+			sc-&gt;result = (DID_OK &lt;&lt; 16) | rhdr-&gt;cmd_status;
+		} else
+			sc-&gt;result = (DID_OK &lt;&lt; 16) | rhdr-&gt;cmd_status;
+	}
+
+	conn-&gt;datain_pdus_cnt++;
+	return 0;
+}
+
+/**
+ * iscsi_solicit_data_init - initialize first Data-Out
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ * @r2t: R2T info
+ *
+ * Notes:
+ *	Initialize first Data-Out within this R2T sequence and finds
+ *	proper data_offset within this SCSI command.
+ *
+ *	This function is called with connection lock taken.
+ **/
+static void
+iscsi_solicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
+			struct iscsi_r2t_info *r2t)
+{
+	struct iscsi_data *hdr;
+	struct iscsi_data_task *dtask;
+	struct scsi_cmnd *sc = ctask-&gt;sc;
+
+	dtask = mempool_alloc(ctask-&gt;datapool, GFP_ATOMIC);
+	BUG_ON(!dtask);
+	hdr = &amp;dtask-&gt;hdr;
+	memset(hdr, 0, sizeof(struct iscsi_data));
+	hdr-&gt;ttt = r2t-&gt;ttt;
+	hdr-&gt;datasn = cpu_to_be32(r2t-&gt;solicit_datasn);
+	r2t-&gt;solicit_datasn++;
+	hdr-&gt;opcode = ISCSI_OP_SCSI_DATA_OUT;
+	memcpy(hdr-&gt;lun, ctask-&gt;hdr.lun, sizeof(hdr-&gt;lun));
+	hdr-&gt;itt = ctask-&gt;hdr.itt;
+	hdr-&gt;exp_statsn = r2t-&gt;exp_statsn;
+	hdr-&gt;offset = cpu_to_be32(r2t-&gt;data_offset);
+	if (r2t-&gt;data_length &gt; conn-&gt;max_xmit_dlength) {
+		hton24(hdr-&gt;dlength, conn-&gt;max_xmit_dlength);
+		r2t-&gt;data_count = conn-&gt;max_xmit_dlength;
+		hdr-&gt;flags = 0;
+	} else {
+		hton24(hdr-&gt;dlength, r2t-&gt;data_length);
+		r2t-&gt;data_count = r2t-&gt;data_length;
+		hdr-&gt;flags = ISCSI_FLAG_CMD_FINAL;
+	}
+	conn-&gt;dataout_pdus_cnt++;
+
+	r2t-&gt;sent = 0;
+
+	iscsi_buf_init_hdr(conn, &amp;r2t-&gt;headbuf, (char*)hdr,
+			   (u8 *)dtask-&gt;hdrext);
+
+	r2t-&gt;dtask = dtask;
+
+	if (sc-&gt;use_sg) {
+		int i, sg_count = 0;
+		struct scatterlist *sg = sc-&gt;request_buffer;
+
+		r2t-&gt;sg = NULL;
+		for (i = 0; i &lt; sc-&gt;use_sg; i++, sg += 1) {
+			/* FIXME: prefetch ? */
+			if (sg_count + sg-&gt;length &gt; r2t-&gt;data_offset) {
+				int page_offset;
+
+				/* sg page found! */
+
+				/* offset within this page */
+				page_offset = r2t-&gt;data_offset - sg_count;
+
+				/* fill in this buffer */
+				iscsi_buf_init_sg(&amp;r2t-&gt;sendbuf, sg);
+				r2t-&gt;sendbuf.sg.offset += page_offset;
+				r2t-&gt;sendbuf.sg.length -= page_offset;
+
+				/* xmit logic will continue with next one */
+				r2t-&gt;sg = sg + 1;
+				break;
+			}
+			sg_count += sg-&gt;length;
+		}
+		BUG_ON(r2t-&gt;sg == NULL);
+	} else
+		iscsi_buf_init_iov(&amp;ctask-&gt;sendbuf,
+			    (char*)sc-&gt;request_buffer + r2t-&gt;data_offset,
+			    r2t-&gt;data_count);
+
+	list_add(&amp;dtask-&gt;item, &amp;ctask-&gt;dataqueue);
+}
+
+/**
+ * iscsi_r2t_rsp - iSCSI R2T Response processing
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ **/
+static int
+iscsi_r2t_rsp(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_r2t_info *r2t;
+	struct iscsi_session *session = conn-&gt;session;
+	struct iscsi_r2t_rsp *rhdr = (struct iscsi_r2t_rsp *)conn-&gt;in.hdr;
+	int r2tsn = be32_to_cpu(rhdr-&gt;r2tsn);
+	int rc;
+
+	if (conn-&gt;in.ahslen)
+		return ISCSI_ERR_AHSLEN;
+
+	if (conn-&gt;in.datalen)
+		return ISCSI_ERR_DATALEN;
+
+	if (ctask-&gt;exp_r2tsn &amp;&amp; ctask-&gt;exp_r2tsn != r2tsn)
+		return ISCSI_ERR_R2TSN;
+
+	rc = iscsi_check_assign_cmdsn(session, (struct iscsi_nopin*)rhdr);
+	if (rc)
+		return rc;
+
+	/* FIXME: use R2TSN to detect missing R2T */
+
+	/* fill-in new R2T associated with the task */
+	spin_lock(&amp;session-&gt;lock);
+	if (!ctask-&gt;sc || ctask-&gt;mtask ||
+	     session-&gt;state != ISCSI_STATE_LOGGED_IN) {
+		printk(KERN_INFO "iscsi_tcp: dropping R2T itt %d in "
+		       "recovery...\n", ctask-&gt;itt);
+		spin_unlock(&amp;session-&gt;lock);
+		return 0;
+	}
+	rc = __kfifo_get(ctask-&gt;r2tpool.queue, (void*)&amp;r2t, sizeof(void*));
+	BUG_ON(!rc);
+
+	r2t-&gt;exp_statsn = rhdr-&gt;statsn;
+	r2t-&gt;data_length = be32_to_cpu(rhdr-&gt;data_length);
+	if (r2t-&gt;data_length == 0 ||
+	    r2t-&gt;data_length &gt; session-&gt;max_burst) {
+		spin_unlock(&amp;session-&gt;lock);
+		return ISCSI_ERR_DATALEN;
+	}
+
+	r2t-&gt;data_offset = be32_to_cpu(rhdr-&gt;data_offset);
+	if (r2t-&gt;data_offset + r2t-&gt;data_length &gt; ctask-&gt;total_length) {
+		spin_unlock(&amp;session-&gt;lock);
+		return ISCSI_ERR_DATALEN;
+	}
+
+	r2t-&gt;ttt = rhdr-&gt;ttt; /* no flip */
+	r2t-&gt;solicit_datasn = 0;
+
+	iscsi_solicit_data_init(conn, ctask, r2t);
+
+	ctask-&gt;exp_r2tsn = r2tsn + 1;
+	ctask-&gt;xmstate |= XMSTATE_SOL_HDR;
+	__kfifo_put(ctask-&gt;r2tqueue, (void*)&amp;r2t, sizeof(void*));
+	__kfifo_put(conn-&gt;writequeue, (void*)&amp;ctask, sizeof(void*));
+
+	schedule_work(&amp;conn-&gt;xmitwork);
+	conn-&gt;r2t_pdus_cnt++;
+	spin_unlock(&amp;session-&gt;lock);
+
+	return 0;
+}
+
+static int
+iscsi_hdr_recv(struct iscsi_conn *conn)
+{
+	int rc = 0;
+	struct iscsi_hdr *hdr;
+	struct iscsi_cmd_task *ctask;
+	struct iscsi_session *session = conn-&gt;session;
+	uint32_t cdgst, rdgst = 0;
+
+	hdr = conn-&gt;in.hdr;
+
+	/* verify PDU length */
+	conn-&gt;in.datalen = ntoh24(hdr-&gt;dlength);
+	if (conn-&gt;in.datalen &gt; conn-&gt;max_recv_dlength) {
+		printk(KERN_ERR "iscsi_tcp: datalen %d &gt; %d\n",
+		       conn-&gt;in.datalen, conn-&gt;max_recv_dlength);
+		return ISCSI_ERR_DATALEN;
+	}
+	conn-&gt;data_copied = 0;
+
+	/* read AHS */
+	conn-&gt;in.ahslen = hdr-&gt;hlength*(4*sizeof(__u16));
+	conn-&gt;in.offset += conn-&gt;in.ahslen;
+	conn-&gt;in.copy -= conn-&gt;in.ahslen;
+	if (conn-&gt;in.copy &lt; 0) {
+		printk(KERN_ERR "iscsi_tcp: can't handle AHS with length "
+		       "%d bytes\n", conn-&gt;in.ahslen);
+		return ISCSI_ERR_AHSLEN;
+	}
+
+	/* calculate read padding */
+	conn-&gt;in.padding = conn-&gt;in.datalen &amp; (ISCSI_PAD_LEN-1);
+	if (conn-&gt;in.padding) {
+		conn-&gt;in.padding = ISCSI_PAD_LEN - conn-&gt;in.padding;
+		debug_scsi("read padding %d bytes\n", conn-&gt;in.padding);
+	}
+
+	if (conn-&gt;hdrdgst_en) {
+		struct scatterlist sg;
+
+		sg_init_one(&amp;sg, (u8 *)hdr,
+			    sizeof(struct iscsi_hdr) + conn-&gt;in.ahslen);
+		crypto_digest_digest(conn-&gt;rx_tfm, &amp;sg, 1, (u8 *)&amp;cdgst);
+		rdgst = *(uint32_t*)((char*)hdr + sizeof(struct iscsi_hdr) +
+				     conn-&gt;in.ahslen);
+	}
+
+	/* save opcode for later */
+	conn-&gt;in.opcode = hdr-&gt;opcode;
+
+	/* verify itt (itt encoding: age+cid+itt) */
+	if (hdr-&gt;itt != cpu_to_be32(ISCSI_RESERVED_TAG)) {
+		if ((hdr-&gt;itt &amp; AGE_MASK) !=
+				(session-&gt;age &lt;&lt; AGE_SHIFT)) {
+			printk(KERN_ERR "iscsi_tcp: received itt %x expected "
+				"session age (%x)\n", hdr-&gt;itt,
+				session-&gt;age &amp; AGE_MASK);
+			return ISCSI_ERR_BAD_ITT;
+		}
+
+		if ((hdr-&gt;itt &amp; CID_MASK) != (conn-&gt;id &lt;&lt; CID_SHIFT)) {
+			printk(KERN_ERR "iscsi_tcp: received itt %x, expected "
+				"CID (%x)\n", hdr-&gt;itt, conn-&gt;id);
+			return ISCSI_ERR_BAD_ITT;
+		}
+		conn-&gt;in.itt = hdr-&gt;itt &amp; ITT_MASK;
+	} else
+		conn-&gt;in.itt = hdr-&gt;itt;
+
+	debug_tcp("opcode 0x%x offset %d copy %d ahslen %d datalen %d\n",
+		  hdr-&gt;opcode, conn-&gt;in.offset, conn-&gt;in.copy,
+		  conn-&gt;in.ahslen, conn-&gt;in.datalen);
+
+	if (conn-&gt;in.itt &lt; session-&gt;cmds_max) {
+		if (conn-&gt;hdrdgst_en &amp;&amp; cdgst != rdgst) {
+			printk(KERN_ERR "iscsi_tcp: itt %x: hdrdgst error "
+			       "recv 0x%x calc 0x%x\n", conn-&gt;in.itt, rdgst,
+			       cdgst);
+			return ISCSI_ERR_HDR_DGST;
+		}
+
+		ctask = (struct iscsi_cmd_task *)session-&gt;cmds[conn-&gt;in.itt];
+
+		if (!ctask-&gt;sc) {
+			printk(KERN_INFO "iscsi_tcp: dropping ctask with "
+			       "itt 0x%x\n", ctask-&gt;itt);
+			conn-&gt;in.datalen = 0; /* force drop */
+			return 0;
+		}
+
+		if (ctask-&gt;sc-&gt;SCp.phase != session-&gt;age) {
+			printk(KERN_ERR "iscsi_tcp: ctask's session age %d, "
+				"expected %d\n", ctask-&gt;sc-&gt;SCp.phase,
+				session-&gt;age);
+			return ISCSI_ERR_SESSION_FAILED;
+		}
+
+		conn-&gt;in.ctask = ctask;
+
+		debug_scsi("rsp [op 0x%x cid %d sc %lx itt 0x%x len %d]\n",
+			   hdr-&gt;opcode, conn-&gt;id, (long)ctask-&gt;sc,
+			   ctask-&gt;itt, conn-&gt;in.datalen);
+
+		switch(conn-&gt;in.opcode) {
+		case ISCSI_OP_SCSI_CMD_RSP:
+			BUG_ON((void*)ctask != ctask-&gt;sc-&gt;SCp.ptr);
+			if (ctask-&gt;hdr.flags &amp; ISCSI_FLAG_CMD_WRITE)
+				rc = iscsi_cmd_rsp(conn, ctask);
+			else if (!conn-&gt;in.datalen)
+				rc = iscsi_cmd_rsp(conn, ctask);
+			else
+				/*
+				 * got sense or response data; copying PDU
+				 * Header to the connection's header
+				 * placeholder
+				 */
+				memcpy(&amp;conn-&gt;hdr, hdr,
+				       sizeof(struct iscsi_hdr));
+			break;
+		case ISCSI_OP_SCSI_DATA_IN:
+			BUG_ON((void*)ctask != ctask-&gt;sc-&gt;SCp.ptr);
+			/* save flags for non-exceptional status */
+			conn-&gt;in.flags = hdr-&gt;flags;
+			/* save cmd_status for sense data */
+			conn-&gt;in.cmd_status =
+				((struct iscsi_data_rsp*)hdr)-&gt;cmd_status;
+			rc = iscsi_data_rsp(conn, ctask);
+			break;
+		case ISCSI_OP_R2T:
+			BUG_ON((void*)ctask != ctask-&gt;sc-&gt;SCp.ptr);
+			if (ctask-&gt;hdr.flags &amp; ISCSI_FLAG_CMD_WRITE &amp;&amp;
+			    ctask-&gt;sc-&gt;sc_data_direction == DMA_TO_DEVICE)
+				rc = iscsi_r2t_rsp(conn, ctask);
+			else
+				rc = ISCSI_ERR_PROTO;
+			break;
+		case ISCSI_OP_NOOP_IN:
+		case ISCSI_OP_TEXT_RSP:
+		case ISCSI_OP_LOGOUT_RSP:
+		case ISCSI_OP_ASYNC_EVENT:
+		case ISCSI_OP_REJECT:
+			rc = iscsi_check_assign_cmdsn(session,
+						 (struct iscsi_nopin*)hdr);
+			if (rc)
+				break;
+
+			/* update ExpStatSN */
+			conn-&gt;exp_statsn = be32_to_cpu(hdr-&gt;statsn) + 1;
+			if (!conn-&gt;in.datalen) {
+				struct iscsi_mgmt_task *mtask;
+
+				rc = iscsi_recv_pdu(iscsi_handle(conn), hdr,
+						    NULL, 0);
+				mtask = (struct iscsi_mgmt_task *)
+					session-&gt;mgmt_cmds[conn-&gt;in.itt -
+						ISCSI_MGMT_ITT_OFFSET];
+				if (conn-&gt;login_mtask != mtask) {
+					spin_lock(&amp;session-&gt;lock);
+					__kfifo_put(session-&gt;mgmtpool.queue,
+					    (void*)&amp;mtask, sizeof(void*));
+					spin_unlock(&amp;session-&gt;lock);
+				}
+			}
+			break;
+		default:
+			rc = ISCSI_ERR_BAD_OPCODE;
+			break;
+		}
+	} else if (conn-&gt;in.itt &gt;= ISCSI_MGMT_ITT_OFFSET &amp;&amp;
+		   conn-&gt;in.itt &lt; ISCSI_MGMT_ITT_OFFSET +
+					session-&gt;mgmtpool_max) {
+		struct iscsi_mgmt_task *mtask = (struct iscsi_mgmt_task *)
+					session-&gt;mgmt_cmds[conn-&gt;in.itt -
+						ISCSI_MGMT_ITT_OFFSET];
+
+		debug_scsi("immrsp [op 0x%x cid %d itt 0x%x len %d]\n",
+			   conn-&gt;in.opcode, conn-&gt;id, mtask-&gt;itt,
+			   conn-&gt;in.datalen);
+
+		switch(conn-&gt;in.opcode) {
+		case ISCSI_OP_LOGIN_RSP:
+		case ISCSI_OP_TEXT_RSP:
+			rc = iscsi_check_assign_cmdsn(session,
+						 (struct iscsi_nopin*)hdr);
+			if (rc)
+				break;
+
+			if (!conn-&gt;in.datalen) {
+				rc = iscsi_recv_pdu(iscsi_handle(conn), hdr,
+						    NULL, 0);
+				if (conn-&gt;login_mtask != mtask) {
+					spin_lock(&amp;session-&gt;lock);
+					__kfifo_put(session-&gt;mgmtpool.queue,
+					    (void*)&amp;mtask, sizeof(void*));
+					spin_unlock(&amp;session-&gt;lock);
+				}
+			}
+			break;
+		case ISCSI_OP_SCSI_TMFUNC_RSP:
+			rc = iscsi_check_assign_cmdsn(session,
+						 (struct iscsi_nopin*)hdr);
+			if (rc)
+				break;
+
+			if (conn-&gt;in.datalen || conn-&gt;in.ahslen) {
+				rc = ISCSI_ERR_PROTO;
+				break;
+			}
+			conn-&gt;tmfrsp_pdus_cnt++;
+			spin_lock(&amp;session-&gt;lock);
+			if (conn-&gt;tmabort_state == TMABORT_INITIAL) {
+				__kfifo_put(session-&gt;mgmtpool.queue,
+						(void*)&amp;mtask, sizeof(void*));
+				conn-&gt;tmabort_state =
+					((struct iscsi_tm_rsp *)hdr)-&gt;
+					response == SCSI_TCP_TM_RESP_COMPLETE ?
+						TMABORT_SUCCESS:TMABORT_FAILED;
+				/* unblock eh_abort() */
+				wake_up(&amp;conn-&gt;ehwait);
+			}
+			spin_unlock(&amp;session-&gt;lock);
+			break;
+		default:
+			rc = ISCSI_ERR_BAD_OPCODE;
+			break;
+		}
+	} else if (conn-&gt;in.itt == ISCSI_RESERVED_TAG) {
+		if (conn-&gt;in.opcode == ISCSI_OP_NOOP_IN &amp;&amp; !conn-&gt;in.datalen) {
+			rc = iscsi_check_assign_cmdsn(session,
+						 (struct iscsi_nopin*)hdr);
+			if (!rc)
+				rc = iscsi_recv_pdu(iscsi_handle(conn),
+						    hdr, NULL, 0);
+		}
+		else
+			rc = ISCSI_ERR_BAD_OPCODE;
+	} else
+		rc = ISCSI_ERR_BAD_ITT;
+
+	return rc;
+}
+
+/**
+ * iscsi_ctask_copy - copy skb bits to the destanation cmd task
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ * @buf: buffer to copy to
+ * @buf_size: size of buffer
+ * @offset: offset within the buffer
+ *
+ * Notes:
+ *	The function calls skb_copy_bits() and updates per-connection and
+ *	per-cmd byte counters.
+ *
+ *	Read counters (in bytes):
+ *
+ *	conn-&gt;in.offset		offset within in progress SKB
+ *	conn-&gt;in.copy		left to copy from in progress SKB
+ *				including padding
+ *	conn-&gt;in.copied		copied already from in progress SKB
+ *	conn-&gt;data_copied	copied already from in progress buffer
+ *	ctask-&gt;sent		total bytes sent up to the MidLayer
+ *	ctask-&gt;data_count	left to copy from in progress Data-In
+ *	buf_left		left to copy from in progress buffer
+ **/
+static inline int
+iscsi_ctask_copy(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
+		void *buf, int buf_size, int offset)
+{
+	int buf_left = buf_size - (conn-&gt;data_copied + offset);
+	int size = min(conn-&gt;in.copy, buf_left);
+	int rc;
+
+	size = min(size, ctask-&gt;data_count);
+
+	debug_tcp("ctask_copy %d bytes at offset %d copied %d\n",
+	       size, conn-&gt;in.offset, conn-&gt;in.copied);
+
+	BUG_ON(size &lt;= 0);
+	BUG_ON(ctask-&gt;sent + size &gt; ctask-&gt;total_length);
+
+	rc = skb_copy_bits(conn-&gt;in.skb, conn-&gt;in.offset,
+			   (char*)buf + (offset + conn-&gt;data_copied), size);
+	/* must fit into skb-&gt;len */
+	BUG_ON(rc);
+
+	conn-&gt;in.offset += size;
+	conn-&gt;in.copy -= size;
+	conn-&gt;in.copied += size;
+	conn-&gt;data_copied += size;
+	ctask-&gt;sent += size;
+	ctask-&gt;data_count -= size;
+
+	BUG_ON(conn-&gt;in.copy &lt; 0);
+	BUG_ON(ctask-&gt;data_count &lt; 0);
+
+	if (buf_size != (conn-&gt;data_copied + offset)) {
+		if (!ctask-&gt;data_count) {
+			BUG_ON(buf_size - conn-&gt;data_copied &lt; 0);
+			/* done with this PDU */
+			return buf_size - conn-&gt;data_copied;
+		}
+		return -EAGAIN;
+	}
+
+	/* done with this buffer or with both - PDU and buffer */
+	conn-&gt;data_copied = 0;
+	return 0;
+}
+
+/**
+ * iscsi_tcp_copy - copy skb bits to the destanation buffer
+ * @conn: iscsi connection
+ * @buf: buffer to copy to
+ * @buf_size: number of bytes to copy
+ *
+ * Notes:
+ *	The function calls skb_copy_bits() and updates per-connection
+ *	byte counters.
+ **/
+static inline int
+iscsi_tcp_copy(struct iscsi_conn *conn, void *buf, int buf_size)
+{
+	int buf_left = buf_size - conn-&gt;data_copied;
+	int size = min(conn-&gt;in.copy, buf_left);
+	int rc;
+
+	debug_tcp("tcp_copy %d bytes at offset %d copied %d\n",
+	       size, conn-&gt;in.offset, conn-&gt;data_copied);
+	BUG_ON(size &lt;= 0);
+
+	rc = skb_copy_bits(conn-&gt;in.skb, conn-&gt;in.offset,
+			   (char*)buf + conn-&gt;data_copied, size);
+	BUG_ON(rc);
+
+	conn-&gt;in.offset += size;
+	conn-&gt;in.copy -= size;
+	conn-&gt;in.copied += size;
+	conn-&gt;data_copied += size;
+
+	if (buf_size != conn-&gt;data_copied)
+		return -EAGAIN;
+
+	return 0;
+}
+
+static inline void
+partial_sg_digest_update(struct iscsi_conn *conn, struct scatterlist *sg,
+			 int offset, int length)
+{
+	struct scatterlist temp;
+
+	memcpy(&amp;temp, sg, sizeof(struct scatterlist));
+	temp.offset = offset;
+	temp.length = length;
+	crypto_digest_update(conn-&gt;data_rx_tfm, &amp;temp, 1);
+}
+
+static int iscsi_scsi_data_in(struct iscsi_conn *conn)
+{
+	struct iscsi_cmd_task *ctask = conn-&gt;in.ctask;
+	struct scsi_cmnd *sc = ctask-&gt;sc;
+	struct scatterlist tmp, *sg;
+	int i, offset, rc = 0;
+
+	BUG_ON((void*)ctask != sc-&gt;SCp.ptr);
+
+	/*
+	 * copying Data-In into the Scsi_Cmnd
+	 */
+	if (!sc-&gt;use_sg) {
+		i = ctask-&gt;data_count;
+		rc = iscsi_ctask_copy(conn, ctask, sc-&gt;request_buffer,
+				      sc-&gt;request_bufflen, ctask-&gt;data_offset);
+		if (rc == -EAGAIN)
+			return rc;
+		if (conn-&gt;datadgst_en) {
+			sg_init_one(&amp;tmp, sc-&gt;request_buffer, i);
+			crypto_digest_update(conn-&gt;data_rx_tfm, &amp;tmp, 1);
+		}
+		rc = 0;
+		goto done;
+	}
+
+	offset = ctask-&gt;data_offset;
+	sg = sc-&gt;request_buffer;
+
+	if (ctask-&gt;data_offset)
+		for (i = 0; i &lt; ctask-&gt;sg_count; i++)
+			offset -= sg[i].length;
+	/* we've passed through partial sg*/
+	if (offset &lt; 0)
+		offset = 0;
+
+	for (i = ctask-&gt;sg_count; i &lt; sc-&gt;use_sg; i++) {
+		char *dest;
+
+		dest = kmap_atomic(sg[i].page, KM_SOFTIRQ0);
+		rc = iscsi_ctask_copy(conn, ctask, dest + sg[i].offset,
+				      sg[i].length, offset);
+		kunmap_atomic(dest, KM_SOFTIRQ0);
+		if (rc == -EAGAIN)
+			/* continue with the next SKB/PDU */
+			return rc;
+		if (!rc) {
+			if (conn-&gt;datadgst_en) {
+				if (!offset)
+					crypto_digest_update(conn-&gt;data_rx_tfm,
+							     &amp;sg[i], 1);
+				else
+					partial_sg_digest_update(conn, &amp;sg[i],
+							sg[i].offset + offset,
+							sg[i].length - offset);
+			}
+			offset = 0;
+			ctask-&gt;sg_count++;
+		}
+
+		if (!ctask-&gt;data_count) {
+			if (rc &amp;&amp; conn-&gt;datadgst_en)
+				/*
+				 * data-in is complete, but buffer not...
+				 */
+				partial_sg_digest_update(conn, &amp;sg[i],
+						sg[i].offset, sg[i].length-rc);
+			rc = 0;
+			break;
+		}
+
+		if (!conn-&gt;in.copy)
+			return -EAGAIN;
+	}
+	BUG_ON(ctask-&gt;data_count);
+
+done:
+	/* check for non-exceptional status */
+	if (conn-&gt;in.flags &amp; ISCSI_FLAG_DATA_STATUS) {
+		debug_scsi("done [sc %lx res %d itt 0x%x]\n",
+			   (long)sc, sc-&gt;result, ctask-&gt;itt);
+		conn-&gt;scsirsp_pdus_cnt++;
+		iscsi_ctask_cleanup(conn, ctask);
+		sc-&gt;scsi_done(sc);
+	}
+
+	return rc;
+}
+
+static int
+iscsi_data_recv(struct iscsi_conn *conn)
+{
+	struct iscsi_session *session = conn-&gt;session;
+	int rc = 0;
+
+	switch(conn-&gt;in.opcode) {
+	case ISCSI_OP_SCSI_DATA_IN:
+		rc = iscsi_scsi_data_in(conn);
+		break;
+	case ISCSI_OP_SCSI_CMD_RSP: {
+		/*
+		 * SCSI Sense Data:
+		 * copying the entire Data Segment.
+		 */
+		if (iscsi_tcp_copy(conn, conn-&gt;data, conn-&gt;in.datalen)) {
+			rc = -EAGAIN;
+			goto exit;
+		}
+
+		/*
+		 * check for sense
+		 */
+		conn-&gt;in.hdr = &amp;conn-&gt;hdr;
+		conn-&gt;senselen = (conn-&gt;data[0] &lt;&lt; 8) | conn-&gt;data[1];
+		rc = iscsi_cmd_rsp(conn, conn-&gt;in.ctask);
+	}
+	break;
+	case ISCSI_OP_TEXT_RSP:
+	case ISCSI_OP_LOGIN_RSP:
+	case ISCSI_OP_NOOP_IN: {
+		struct iscsi_mgmt_task *mtask = NULL;
+
+		if (conn-&gt;in.itt != ISCSI_RESERVED_TAG)
+			mtask = (struct iscsi_mgmt_task *)
+				session-&gt;mgmt_cmds[conn-&gt;in.itt -
+					ISCSI_MGMT_ITT_OFFSET];
+
+		/*
+		 * Collect data segment to the connection's data
+		 * placeholder
+		 */
+		if (iscsi_tcp_copy(conn, conn-&gt;data, conn-&gt;in.datalen)) {
+			rc = -EAGAIN;
+			goto exit;
+		}
+
+		rc = iscsi_recv_pdu(iscsi_handle(conn), conn-&gt;in.hdr,
+				    conn-&gt;data, conn-&gt;in.datalen);
+
+		if (mtask &amp;&amp; conn-&gt;login_mtask != mtask) {
+			spin_lock(&amp;session-&gt;lock);
+			__kfifo_put(session-&gt;mgmtpool.queue, (void*)&amp;mtask,
+				    sizeof(void*));
+			spin_unlock(&amp;session-&gt;lock);
+		}
+	}
+	break;
+	default:
+		BUG_ON(1);
+	}
+exit:
+	return rc;
+}
+
+/**
+ * iscsi_tcp_data_recv - TCP receive in sendfile fashion
+ * @rd_desc: read descriptor
+ * @skb: socket buffer
+ * @offset: offset in skb
+ * @len: skb-&gt;len - offset
+ **/
+static int
+iscsi_tcp_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
+		unsigned int offset, size_t len)
+{
+	int rc;
+	struct iscsi_conn *conn = rd_desc-&gt;arg.data;
+	int start = skb_headlen(skb);
+	int processed;
+	char pad[ISCSI_PAD_LEN];
+	struct scatterlist sg;
+
+	/*
+	 * Save current SKB and its offset in the corresponding
+	 * connection context.
+	 */
+	conn-&gt;in.copy = start - offset;
+	conn-&gt;in.offset = offset;
+	conn-&gt;in.skb = skb;
+	conn-&gt;in.len = conn-&gt;in.copy;
+	BUG_ON(conn-&gt;in.copy &lt;= 0);
+	debug_tcp("in %d bytes\n", conn-&gt;in.copy);
+
+more:
+	conn-&gt;in.copied = 0;
+	rc = 0;
+
+	if (unlikely(conn-&gt;suspend_rx)) {
+		debug_tcp("conn %d Rx suspended!\n", conn-&gt;id);
+		return 0;
+	}
+
+	if (conn-&gt;in_progress == IN_PROGRESS_WAIT_HEADER ||
+	    conn-&gt;in_progress == IN_PROGRESS_HEADER_GATHER) {
+		rc = iscsi_hdr_extract(conn);
+		if (rc) {
+		       if (rc == -EAGAIN)
+				goto nomore;
+		       else {
+				iscsi_conn_failure(conn, rc);
+				return 0;
+		       }
+		}
+
+		/*
+		 * Verify and process incoming PDU header.
+		 */
+		rc = iscsi_hdr_recv(conn);
+		if (!rc &amp;&amp; conn-&gt;in.datalen) {
+			if (conn-&gt;datadgst_en &amp;&amp;
+			    conn-&gt;in.opcode == ISCSI_OP_SCSI_DATA_IN) {
+				BUG_ON(!conn-&gt;data_rx_tfm);
+				crypto_digest_init(conn-&gt;data_rx_tfm);
+			}
+			conn-&gt;in_progress = IN_PROGRESS_DATA_RECV;
+		} else if (rc) {
+			iscsi_conn_failure(conn, rc);
+			return 0;
+		}
+	}
+
+	if (conn-&gt;in_progress == IN_PROGRESS_DDIGEST_RECV) {
+		debug_tcp("extra data_recv offset %d copy %d\n",
+			  conn-&gt;in.offset, conn-&gt;in.copy);
+		if (conn-&gt;in.opcode == ISCSI_OP_SCSI_DATA_IN) {
+			uint32_t recv_digest;
+			skb_copy_bits(conn-&gt;in.skb, conn-&gt;in.offset,
+				      &amp;recv_digest, 4);
+			conn-&gt;in.offset += 4;
+			conn-&gt;in.copy -= 4;
+			if (recv_digest != conn-&gt;in.datadgst) {
+				debug_tcp("iscsi_tcp: data digest error!"
+					  "0x%x != 0x%x\n", recv_digest,
+					  conn-&gt;in.datadgst);
+				iscsi_conn_failure(conn, ISCSI_ERR_DATA_DGST);
+				return 0;
+			} else {
+				debug_tcp("iscsi_tcp: data digest match!"
+					  "0x%x == 0x%x\n", recv_digest,
+					  conn-&gt;in.datadgst);
+				conn-&gt;in_progress = IN_PROGRESS_WAIT_HEADER;
+			}
+		}
+	}
+
+	if (conn-&gt;in_progress == IN_PROGRESS_DATA_RECV &amp;&amp; conn-&gt;in.copy) {
+
+		debug_tcp("data_recv offset %d copy %d\n",
+		       conn-&gt;in.offset, conn-&gt;in.copy);
+
+		rc = iscsi_data_recv(conn);
+		if (rc) {
+			if (rc == -EAGAIN) {
+				rd_desc-&gt;count = conn-&gt;in.datalen -
+						conn-&gt;in.ctask-&gt;data_count;
+				goto again;
+			}
+			iscsi_conn_failure(conn, rc);
+			return 0;
+		}
+		conn-&gt;in.copy -= conn-&gt;in.padding;
+		conn-&gt;in.offset += conn-&gt;in.padding;
+		if (conn-&gt;datadgst_en &amp;&amp;
+		    conn-&gt;in.opcode == ISCSI_OP_SCSI_DATA_IN) {
+			if (conn-&gt;in.padding) {
+				debug_tcp("padding -&gt; %d\n", conn-&gt;in.padding);
+				memset(pad, 0, conn-&gt;in.padding);
+				sg_init_one(&amp;sg, pad, conn-&gt;in.padding);
+				crypto_digest_update(conn-&gt;data_rx_tfm, &amp;sg, 1);
+			}
+			crypto_digest_final(conn-&gt;data_rx_tfm,
+					    (u8 *) &amp; conn-&gt;in.datadgst);
+			debug_tcp("rx digest 0x%x\n", conn-&gt;in.datadgst);
+			conn-&gt;in_progress = IN_PROGRESS_DDIGEST_RECV;
+		} else
+			conn-&gt;in_progress = IN_PROGRESS_WAIT_HEADER;
+	}
+
+	debug_tcp("f, processed %d from out of %d padding %d\n",
+	       conn-&gt;in.offset - offset, (int)len, conn-&gt;in.padding);
+	BUG_ON(conn-&gt;in.offset - offset &gt; len);
+
+	if (conn-&gt;in.offset - offset != len) {
+		debug_tcp("continue to process %d bytes\n",
+		       (int)len - (conn-&gt;in.offset - offset));
+		goto more;
+	}
+
+nomore:
+	processed = conn-&gt;in.offset - offset;
+	BUG_ON(processed == 0);
+	return processed;
+
+again:
+	processed = conn-&gt;in.offset - offset;
+	debug_tcp("c, processed %d from out of %d rd_desc_cnt %d\n",
+	          processed, (int)len, (int)rd_desc-&gt;count);
+	BUG_ON(processed == 0);
+	BUG_ON(processed &gt; len);
+
+	conn-&gt;rxdata_octets += processed;
+	return processed;
+}
+
+static void
+iscsi_tcp_data_ready(struct sock *sk, int flag)
+{
+	struct iscsi_conn *conn = sk-&gt;sk_user_data;
+	read_descriptor_t rd_desc;
+
+	read_lock(&amp;sk-&gt;sk_callback_lock);
+
+	/* use rd_desc to pass 'conn' to iscsi_tcp_data_recv */
+	rd_desc.arg.data = conn;
+	rd_desc.count = 0;
+	tcp_read_sock(sk, &amp;rd_desc, iscsi_tcp_data_recv);
+
+	read_unlock(&amp;sk-&gt;sk_callback_lock);
+}
+
+static void
+iscsi_tcp_state_change(struct sock *sk)
+{
+	struct iscsi_conn *conn;
+	struct iscsi_session *session;
+	void (*old_state_change)(struct sock *);
+
+	read_lock(&amp;sk-&gt;sk_callback_lock);
+
+	conn = (struct iscsi_conn*)sk-&gt;sk_user_data;
+	session = conn-&gt;session;
+
+	if (sk-&gt;sk_state == TCP_CLOSE_WAIT ||
+	    sk-&gt;sk_state == TCP_CLOSE) {
+		debug_tcp("iscsi_tcp_state_change: TCP_CLOSE|TCP_CLOSE_WAIT\n");
+		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+	}
+
+	old_state_change = conn-&gt;old_state_change;
+
+	read_unlock(&amp;sk-&gt;sk_callback_lock);
+
+	old_state_change(sk);
+}
+
+/**
+ * iscsi_write_space - Called when more output buffer space is available
+ * @sk: socket space is available for
+ **/
+static void
+iscsi_write_space(struct sock *sk)
+{
+	struct iscsi_conn *conn = (struct iscsi_conn*)sk-&gt;sk_user_data;
+	conn-&gt;old_write_space(sk);
+	debug_tcp("iscsi_write_space: cid %d\n", conn-&gt;id);
+	clear_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+	schedule_work(&amp;conn-&gt;xmitwork);
+}
+
+static void
+iscsi_conn_set_callbacks(struct iscsi_conn *conn)
+{
+	struct sock *sk = conn-&gt;sock-&gt;sk;
+
+	/* assign new callbacks */
+	write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+	sk-&gt;sk_user_data = conn;
+	conn-&gt;old_data_ready = sk-&gt;sk_data_ready;
+	conn-&gt;old_state_change = sk-&gt;sk_state_change;
+	conn-&gt;old_write_space = sk-&gt;sk_write_space;
+	sk-&gt;sk_data_ready = iscsi_tcp_data_ready;
+	sk-&gt;sk_state_change = iscsi_tcp_state_change;
+	sk-&gt;sk_write_space = iscsi_write_space;
+	write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+}
+
+static void
+iscsi_conn_restore_callbacks(struct iscsi_conn *conn)
+{
+	struct sock *sk = conn-&gt;sock-&gt;sk;
+
+	/* restore socket callbacks, see also: iscsi_conn_set_callbacks() */
+	write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+	sk-&gt;sk_user_data    = NULL;
+	sk-&gt;sk_data_ready   = conn-&gt;old_data_ready;
+	sk-&gt;sk_state_change = conn-&gt;old_state_change;
+	sk-&gt;sk_write_space  = conn-&gt;old_write_space;
+	sk-&gt;sk_no_check	 = 0;
+	write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+}
+
+/**
+ * iscsi_send - generic send routine
+ * @sk: kernel's socket
+ * @buf: buffer to write from
+ * @size: actual size to write
+ * @flags: socket's flags
+ *
+ * Notes:
+ *	depending on buffer will use tcp_sendpage() or tcp_sendmsg().
+ *	buf-&gt;sg.offset == -1 tells us that buffer is non S/G and forces
+ *	to use tcp_sendmsg().
+ */
+static inline int
+iscsi_send(struct socket *sk, struct iscsi_buf *buf, int size, int flags)
+{
+	int res;
+
+	if ((int)buf-&gt;sg.offset &gt;= 0) {
+		int offset = buf-&gt;sg.offset + buf-&gt;sent;
+
+		/* tcp_sendpage */
+		res = sk-&gt;ops-&gt;sendpage(sk, buf-&gt;sg.page, offset, size, flags);
+	} else {
+		struct msghdr msg;
+
+		buf-&gt;iov.iov_base = iscsi_buf_iov_base(buf);
+		buf-&gt;iov.iov_len = size;
+
+		memset(&amp;msg, 0, sizeof(struct msghdr));
+
+		/* tcp_sendmsg */
+		res = kernel_sendmsg(sk, &amp;msg, &amp;buf-&gt;iov, 1, size);
+	}
+
+	return res;
+}
+
+/**
+ * iscsi_sendhdr - send PDU Header via tcp_sendpage()
+ * @conn: iscsi connection
+ * @buf: buffer to write from
+ * @datalen: lenght of data to be sent after the header
+ *
+ * Notes:
+ *	(Tx, Fast Path)
+ **/
+static inline int
+iscsi_sendhdr(struct iscsi_conn *conn, struct iscsi_buf *buf, int datalen)
+{
+	struct socket *sk = conn-&gt;sock;
+	int flags = 0; /* MSG_DONTWAIT; */
+	int res, size;
+
+	size = buf-&gt;sg.length - buf-&gt;sent;
+	BUG_ON(buf-&gt;sent + size &gt; buf-&gt;sg.length);
+	if (buf-&gt;sent + size != buf-&gt;sg.length || datalen)
+		flags |= MSG_MORE;
+
+	res = iscsi_send(sk, buf, size, flags);
+	debug_tcp("sendhdr %d bytes, sent %d res %d\n", size, buf-&gt;sent, res);
+	if (res &gt;= 0) {
+		conn-&gt;txdata_octets += res;
+		buf-&gt;sent += res;
+		if (size != res)
+			return -EAGAIN;
+		return 0;
+	} else if (res == -EAGAIN) {
+		conn-&gt;sendpage_failures_cnt++;
+		set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+	} else if (res == -EPIPE)
+		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+
+	return res;
+}
+
+/**
+ * iscsi_sendpage - send one page of iSCSI Data-Out.
+ * @conn: iscsi connection
+ * @buf: buffer to write from
+ * @count: remaining data
+ * @sent: number of bytes sent
+ *
+ * Notes:
+ *	(Tx, Fast Path)
+ **/
+static inline int
+iscsi_sendpage(struct iscsi_conn *conn, struct iscsi_buf *buf,
+	       int *count, int *sent)
+{
+	struct socket *sk = conn-&gt;sock;
+	int flags = 0; /* MSG_DONTWAIT; */
+	int res, size;
+
+	size = buf-&gt;sg.length - buf-&gt;sent;
+	BUG_ON(buf-&gt;sent + size &gt; buf-&gt;sg.length);
+	if (size &gt; *count)
+		size = *count;
+	if (buf-&gt;sent + size != buf-&gt;sg.length)
+		flags |= MSG_MORE;
+
+	res = iscsi_send(sk, buf, size, flags);
+	debug_tcp("sendpage: %d bytes, sent %d left %d sent %d res %d\n",
+		  size, buf-&gt;sent, *count, *sent, res);
+	if (res &gt;= 0) {
+		conn-&gt;txdata_octets += res;
+		buf-&gt;sent += res;
+		*count -= res;
+		*sent += res;
+		if (size != res)
+			return -EAGAIN;
+		return 0;
+	} else if (res == -EAGAIN) {
+		conn-&gt;sendpage_failures_cnt++;
+		set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+	} else if (res == -EPIPE)
+		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+
+	return res;
+}
+
+static inline void
+iscsi_data_digest_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	BUG_ON(!conn-&gt;data_tx_tfm);
+	crypto_digest_init(conn-&gt;data_tx_tfm);
+	ctask-&gt;digest_count = 4;
+}
+
+static inline void
+iscsi_buf_data_digest_update(struct iscsi_conn *conn, struct iscsi_buf *buf)
+{
+	struct scatterlist sg;
+
+	if (buf-&gt;sg.offset != -1)
+		crypto_digest_update(conn-&gt;data_tx_tfm, &amp;buf-&gt;sg, 1);
+	else {
+		sg_init_one(&amp;sg, (char *)buf-&gt;sg.page, buf-&gt;sg.length);
+		crypto_digest_update(conn-&gt;data_tx_tfm, &amp;sg, 1);
+	}
+}
+
+static inline int
+iscsi_digest_final_send(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
+			struct iscsi_buf *buf, uint32_t *digest, int final)
+{
+	int rc = 0;
+	int sent = 0;
+
+	if (final)
+		crypto_digest_final(conn-&gt;data_tx_tfm, (u8*)digest);
+
+	iscsi_buf_init_virt(buf, (char*)digest, 4);
+	rc = iscsi_sendpage(conn, buf, &amp;ctask-&gt;digest_count, &amp;sent);
+	if (rc) {
+		ctask-&gt;datadigest = *digest;
+		ctask-&gt;xmstate |= XMSTATE_DATA_DIGEST;
+	} else
+		ctask-&gt;digest_count = 4;
+	return rc;
+}
+
+/**
+ * iscsi_solicit_data_cont - initialize next Data-Out
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ * @r2t: R2T info
+ * @left: bytes left to transfer
+ *
+ * Notes:
+ *	Initialize next Data-Out within this R2T sequence and continue
+ *	to process next Scatter-Gather element(if any) of this SCSI command.
+ *
+ *	Called under connection lock.
+ **/
+static void
+iscsi_solicit_data_cont(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
+			struct iscsi_r2t_info *r2t, int left)
+{
+	struct iscsi_data *hdr;
+	struct iscsi_data_task *dtask;
+	struct scsi_cmnd *sc = ctask-&gt;sc;
+	int new_offset;
+
+	dtask = mempool_alloc(ctask-&gt;datapool, GFP_ATOMIC);
+	BUG_ON(!dtask);
+	hdr = &amp;dtask-&gt;hdr;
+	memset(hdr, 0, sizeof(struct iscsi_data));
+	hdr-&gt;ttt = r2t-&gt;ttt;
+	hdr-&gt;datasn = cpu_to_be32(r2t-&gt;solicit_datasn);
+	r2t-&gt;solicit_datasn++;
+	hdr-&gt;opcode = ISCSI_OP_SCSI_DATA_OUT;
+	memcpy(hdr-&gt;lun, ctask-&gt;hdr.lun, sizeof(hdr-&gt;lun));
+	hdr-&gt;itt = ctask-&gt;hdr.itt;
+	hdr-&gt;exp_statsn = r2t-&gt;exp_statsn;
+	new_offset = r2t-&gt;data_offset + r2t-&gt;sent;
+	hdr-&gt;offset = cpu_to_be32(new_offset);
+	if (left &gt; conn-&gt;max_xmit_dlength) {
+		hton24(hdr-&gt;dlength, conn-&gt;max_xmit_dlength);
+		r2t-&gt;data_count = conn-&gt;max_xmit_dlength;
+	} else {
+		hton24(hdr-&gt;dlength, left);
+		r2t-&gt;data_count = left;
+		hdr-&gt;flags = ISCSI_FLAG_CMD_FINAL;
+	}
+	conn-&gt;dataout_pdus_cnt++;
+
+	iscsi_buf_init_hdr(conn, &amp;r2t-&gt;headbuf, (char*)hdr,
+			   (u8 *)dtask-&gt;hdrext);
+
+	r2t-&gt;dtask = dtask;
+
+	if (sc-&gt;use_sg &amp;&amp; !iscsi_buf_left(&amp;r2t-&gt;sendbuf)) {
+		BUG_ON(ctask-&gt;bad_sg == r2t-&gt;sg);
+		iscsi_buf_init_sg(&amp;r2t-&gt;sendbuf, r2t-&gt;sg);
+		r2t-&gt;sg += 1;
+	} else
+		iscsi_buf_init_iov(&amp;ctask-&gt;sendbuf,
+			    (char*)sc-&gt;request_buffer + new_offset,
+			    r2t-&gt;data_count);
+
+	list_add(&amp;dtask-&gt;item, &amp;ctask-&gt;dataqueue);
+}
+
+static void
+iscsi_unsolicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_data *hdr;
+	struct iscsi_data_task *dtask;
+
+	dtask = mempool_alloc(ctask-&gt;datapool, GFP_ATOMIC);
+	BUG_ON(!dtask);
+	hdr = &amp;dtask-&gt;hdr;
+	memset(hdr, 0, sizeof(struct iscsi_data));
+	hdr-&gt;ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
+	hdr-&gt;datasn = cpu_to_be32(ctask-&gt;unsol_datasn);
+	ctask-&gt;unsol_datasn++;
+	hdr-&gt;opcode = ISCSI_OP_SCSI_DATA_OUT;
+	memcpy(hdr-&gt;lun, ctask-&gt;hdr.lun, sizeof(hdr-&gt;lun));
+	hdr-&gt;itt = ctask-&gt;hdr.itt;
+	hdr-&gt;exp_statsn = cpu_to_be32(conn-&gt;exp_statsn);
+	hdr-&gt;offset = cpu_to_be32(ctask-&gt;total_length -
+				  ctask-&gt;r2t_data_count -
+				  ctask-&gt;unsol_count);
+	if (ctask-&gt;unsol_count &gt; conn-&gt;max_xmit_dlength) {
+		hton24(hdr-&gt;dlength, conn-&gt;max_xmit_dlength);
+		ctask-&gt;data_count = conn-&gt;max_xmit_dlength;
+		hdr-&gt;flags = 0;
+	} else {
+		hton24(hdr-&gt;dlength, ctask-&gt;unsol_count);
+		ctask-&gt;data_count = ctask-&gt;unsol_count;
+		hdr-&gt;flags = ISCSI_FLAG_CMD_FINAL;
+	}
+
+	iscsi_buf_init_hdr(conn, &amp;ctask-&gt;headbuf, (char*)hdr,
+			   (u8 *)dtask-&gt;hdrext);
+
+	list_add(&amp;dtask-&gt;item, &amp;ctask-&gt;dataqueue);
+
+	ctask-&gt;dtask = dtask;
+}
+
+/**
+ * iscsi_cmd_init - Initialize iSCSI SCSI_READ or SCSI_WRITE commands
+ * @conn: iscsi connection
+ * @ctask: scsi command task
+ * @sc: scsi command
+ **/
+static void
+iscsi_cmd_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask,
+		struct scsi_cmnd *sc)
+{
+	struct iscsi_session *session = conn-&gt;session;
+
+	BUG_ON(__kfifo_len(ctask-&gt;r2tqueue));
+
+	ctask-&gt;sc = sc;
+	ctask-&gt;conn = conn;
+	ctask-&gt;hdr.opcode = ISCSI_OP_SCSI_CMD;
+	ctask-&gt;hdr.flags = ISCSI_ATTR_SIMPLE;
+	int_to_scsilun(sc-&gt;device-&gt;lun, (struct scsi_lun *)ctask-&gt;hdr.lun);
+	ctask-&gt;hdr.itt = ctask-&gt;itt | (conn-&gt;id &lt;&lt; CID_SHIFT) |
+			 (session-&gt;age &lt;&lt; AGE_SHIFT);
+	ctask-&gt;hdr.data_length = cpu_to_be32(sc-&gt;request_bufflen);
+	ctask-&gt;hdr.cmdsn = cpu_to_be32(session-&gt;cmdsn); session-&gt;cmdsn++;
+	ctask-&gt;hdr.exp_statsn = cpu_to_be32(conn-&gt;exp_statsn);
+	memcpy(ctask-&gt;hdr.cdb, sc-&gt;cmnd, sc-&gt;cmd_len);
+	memset(&amp;ctask-&gt;hdr.cdb[sc-&gt;cmd_len], 0, MAX_COMMAND_SIZE - sc-&gt;cmd_len);
+
+	ctask-&gt;mtask = NULL;
+	ctask-&gt;sent = 0;
+	ctask-&gt;sg_count = 0;
+
+	ctask-&gt;total_length = sc-&gt;request_bufflen;
+
+	if (sc-&gt;sc_data_direction == DMA_TO_DEVICE) {
+		ctask-&gt;exp_r2tsn = 0;
+		ctask-&gt;hdr.flags |= ISCSI_FLAG_CMD_WRITE;
+		BUG_ON(ctask-&gt;total_length == 0);
+		if (sc-&gt;use_sg) {
+			struct scatterlist *sg = sc-&gt;request_buffer;
+
+			iscsi_buf_init_sg(&amp;ctask-&gt;sendbuf,
+					  &amp;sg[ctask-&gt;sg_count++]);
+			ctask-&gt;sg = sg;
+			ctask-&gt;bad_sg = sg + sc-&gt;use_sg;
+		} else {
+			iscsi_buf_init_iov(&amp;ctask-&gt;sendbuf, sc-&gt;request_buffer,
+					sc-&gt;request_bufflen);
+		}
+
+		/*
+		 * Write counters:
+		 *
+		 *	imm_count	bytes to be sent right after
+		 *			SCSI PDU Header
+		 *
+		 *	unsol_count	bytes(as Data-Out) to be sent
+		 *			without	R2T ack right after
+		 *			immediate data
+		 *
+		 *	r2t_data_count	bytes to be sent via R2T ack's
+		 *
+		 *      pad_count       bytes to be sent as zero-padding
+		 */
+		ctask-&gt;imm_count = 0;
+		ctask-&gt;unsol_count = 0;
+		ctask-&gt;unsol_datasn = 0;
+		ctask-&gt;xmstate = XMSTATE_W_HDR;
+		/* calculate write padding */
+		ctask-&gt;pad_count = ctask-&gt;total_length &amp; (ISCSI_PAD_LEN-1);
+		if (ctask-&gt;pad_count) {
+			ctask-&gt;pad_count = ISCSI_PAD_LEN - ctask-&gt;pad_count;
+			debug_scsi("write padding %d bytes\n",
+				ctask-&gt;pad_count);
+			ctask-&gt;xmstate |= XMSTATE_W_PAD;
+		}
+		if (session-&gt;imm_data_en) {
+			if (ctask-&gt;total_length &gt;= session-&gt;first_burst)
+				ctask-&gt;imm_count = min(session-&gt;first_burst,
+							conn-&gt;max_xmit_dlength);
+			else
+				ctask-&gt;imm_count = min(ctask-&gt;total_length,
+							conn-&gt;max_xmit_dlength);
+			hton24(ctask-&gt;hdr.dlength, ctask-&gt;imm_count);
+			ctask-&gt;xmstate |= XMSTATE_IMM_DATA;
+		} else
+			zero_data(ctask-&gt;hdr.dlength);
+
+		if (!session-&gt;initial_r2t_en)
+			ctask-&gt;unsol_count = min(session-&gt;first_burst,
+				ctask-&gt;total_length) - ctask-&gt;imm_count;
+		if (!ctask-&gt;unsol_count)
+			/* No unsolicit Data-Out's */
+			ctask-&gt;hdr.flags |= ISCSI_FLAG_CMD_FINAL;
+		else
+			ctask-&gt;xmstate |= XMSTATE_UNS_HDR | XMSTATE_UNS_INIT;
+
+		ctask-&gt;r2t_data_count = ctask-&gt;total_length -
+				    ctask-&gt;imm_count -
+				    ctask-&gt;unsol_count;
+
+		debug_scsi("cmd [itt %x total %d imm %d imm_data %d "
+			   "r2t_data %d]\n",
+			   ctask-&gt;itt, ctask-&gt;total_length, ctask-&gt;imm_count,
+			   ctask-&gt;unsol_count, ctask-&gt;r2t_data_count);
+	} else {
+		ctask-&gt;hdr.flags |= ISCSI_FLAG_CMD_FINAL;
+		if (sc-&gt;sc_data_direction == DMA_FROM_DEVICE)
+			ctask-&gt;hdr.flags |= ISCSI_FLAG_CMD_READ;
+		ctask-&gt;datasn = 0;
+		ctask-&gt;xmstate = XMSTATE_R_HDR;
+		zero_data(ctask-&gt;hdr.dlength);
+	}
+
+	iscsi_buf_init_hdr(conn, &amp;ctask-&gt;headbuf, (char*)&amp;ctask-&gt;hdr,
+			    (u8 *)ctask-&gt;hdrext);
+	conn-&gt;scsicmd_pdus_cnt++;
+}
+
+/**
+ * iscsi_mtask_xmit - xmit management(immediate) task
+ * @conn: iscsi connection
+ * @mtask: task management task
+ *
+ * Notes:
+ *	The function can return -EAGAIN in which case caller must
+ *	call it again later, or recover. '0' return code means successful
+ *	xmit.
+ *
+ *	Management xmit state machine consists of two states:
+ *		IN_PROGRESS_IMM_HEAD - PDU Header xmit in progress
+ *		IN_PROGRESS_IMM_DATA - PDU Data xmit in progress
+ **/
+static int
+iscsi_mtask_xmit(struct iscsi_conn *conn, struct iscsi_mgmt_task *mtask)
+{
+
+	debug_scsi("mtask deq [cid %d state %x itt 0x%x]\n",
+		conn-&gt;id, mtask-&gt;xmstate, mtask-&gt;itt);
+
+	if (mtask-&gt;xmstate &amp; XMSTATE_IMM_HDR) {
+		mtask-&gt;xmstate &amp;= ~XMSTATE_IMM_HDR;
+		if (mtask-&gt;data_count)
+			mtask-&gt;xmstate |= XMSTATE_IMM_DATA;
+		if (iscsi_sendhdr(conn, &amp;mtask-&gt;headbuf, mtask-&gt;data_count)) {
+			mtask-&gt;xmstate |= XMSTATE_IMM_HDR;
+			if (mtask-&gt;data_count)
+				mtask-&gt;xmstate &amp;= ~XMSTATE_IMM_DATA;
+			return -EAGAIN;
+		}
+	}
+
+	if (mtask-&gt;xmstate &amp; XMSTATE_IMM_DATA) {
+		BUG_ON(!mtask-&gt;data_count);
+		mtask-&gt;xmstate &amp;= ~XMSTATE_IMM_DATA;
+		/* FIXME: implement.
+		 * Virtual buffer could be spreaded across multiple pages...
+		 */
+		do {
+			if (iscsi_sendpage(conn, &amp;mtask-&gt;sendbuf,
+				   &amp;mtask-&gt;data_count, &amp;mtask-&gt;sent)) {
+				mtask-&gt;xmstate |= XMSTATE_IMM_DATA;
+				return -EAGAIN;
+			}
+		} while (mtask-&gt;data_count);
+	}
+
+	BUG_ON(mtask-&gt;xmstate != XMSTATE_IDLE);
+	return 0;
+}
+
+static inline int
+handle_xmstate_r_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	ctask-&gt;xmstate &amp;= ~XMSTATE_R_HDR;
+	if (!iscsi_sendhdr(conn, &amp;ctask-&gt;headbuf, 0)) {
+		BUG_ON(ctask-&gt;xmstate != XMSTATE_IDLE);
+		return 0; /* wait for Data-In */
+	}
+	ctask-&gt;xmstate |= XMSTATE_R_HDR;
+	return -EAGAIN;
+}
+
+static inline int
+handle_xmstate_w_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	ctask-&gt;xmstate &amp;= ~XMSTATE_W_HDR;
+	if (iscsi_sendhdr(conn, &amp;ctask-&gt;headbuf, ctask-&gt;imm_count)) {
+		ctask-&gt;xmstate |= XMSTATE_W_HDR;
+		return -EAGAIN;
+	}
+	return 0;
+}
+
+static inline int
+handle_xmstate_data_digest(struct iscsi_conn *conn,
+			   struct iscsi_cmd_task *ctask)
+{
+	ctask-&gt;xmstate &amp;= ~XMSTATE_DATA_DIGEST;
+	debug_tcp("resent data digest 0x%x\n", ctask-&gt;datadigest);
+	if (iscsi_digest_final_send(conn, ctask, &amp;ctask-&gt;immbuf,
+				    &amp;ctask-&gt;datadigest, 0)) {
+		ctask-&gt;xmstate |= XMSTATE_DATA_DIGEST;
+		debug_tcp("resent data digest 0x%x fail!\n",
+			  ctask-&gt;datadigest);
+		return -EAGAIN;
+	}
+	return 0;
+}
+
+static inline int
+handle_xmstate_imm_data(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	BUG_ON(!ctask-&gt;imm_count);
+	ctask-&gt;xmstate &amp;= ~XMSTATE_IMM_DATA;
+
+	if (conn-&gt;datadgst_en) {
+		iscsi_data_digest_init(conn, ctask);
+		ctask-&gt;immdigest = 0;
+	}
+
+	for (;;) {
+		if (iscsi_sendpage(conn, &amp;ctask-&gt;sendbuf, &amp;ctask-&gt;imm_count,
+				   &amp;ctask-&gt;sent)) {
+			ctask-&gt;xmstate |= XMSTATE_IMM_DATA;
+			if (conn-&gt;datadgst_en) {
+				crypto_digest_final(conn-&gt;data_tx_tfm,
+						(u8*)&amp;ctask-&gt;immdigest);
+				debug_tcp("tx imm sendpage fail 0x%x\n",
+					  ctask-&gt;datadigest);
+			}
+			return -EAGAIN;
+		}
+		if (conn-&gt;datadgst_en)
+			iscsi_buf_data_digest_update(conn, &amp;ctask-&gt;sendbuf);
+
+		if (!ctask-&gt;imm_count)
+			break;
+		iscsi_buf_init_sg(&amp;ctask-&gt;sendbuf,
+				  &amp;ctask-&gt;sg[ctask-&gt;sg_count++]);
+	}
+
+	if (conn-&gt;datadgst_en &amp;&amp; !(ctask-&gt;xmstate &amp; XMSTATE_W_PAD)) {
+		if (iscsi_digest_final_send(conn, ctask, &amp;ctask-&gt;immbuf,
+				            &amp;ctask-&gt;immdigest, 1)) {
+			debug_tcp("sending imm digest 0x%x fail!\n",
+				  ctask-&gt;immdigest);
+			return -EAGAIN;
+		}
+		debug_tcp("sending imm digest 0x%x\n", ctask-&gt;immdigest);
+	}
+
+	return 0;
+}
+
+static inline int
+handle_xmstate_uns_hdr(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_data_task *dtask;
+
+	ctask-&gt;xmstate |= XMSTATE_UNS_DATA;
+	if (ctask-&gt;xmstate &amp; XMSTATE_UNS_INIT) {
+		iscsi_unsolicit_data_init(conn, ctask);
+		BUG_ON(!ctask-&gt;dtask);
+		dtask = ctask-&gt;dtask;
+
+		ctask-&gt;xmstate &amp;= ~XMSTATE_UNS_INIT;
+	}
+	if (iscsi_sendhdr(conn, &amp;ctask-&gt;headbuf, ctask-&gt;data_count)) {
+		ctask-&gt;xmstate &amp;= ~XMSTATE_UNS_DATA;
+		ctask-&gt;xmstate |= XMSTATE_UNS_HDR;
+		return -EAGAIN;
+	}
+
+	debug_scsi("uns dout [itt 0x%x dlen %d sent %d]\n",
+		   ctask-&gt;itt, ctask-&gt;unsol_count, ctask-&gt;sent);
+	return 0;
+}
+
+static inline int
+handle_xmstate_uns_data(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_data_task *dtask = ctask-&gt;dtask;
+
+	BUG_ON(!ctask-&gt;data_count);
+	ctask-&gt;xmstate &amp;= ~XMSTATE_UNS_DATA;
+
+	if (conn-&gt;datadgst_en) {
+		iscsi_data_digest_init(conn, ctask);
+		dtask-&gt;digest = 0;
+	}
+
+	for (;;) {
+		int start = ctask-&gt;sent;
+
+		if (iscsi_sendpage(conn, &amp;ctask-&gt;sendbuf, &amp;ctask-&gt;data_count,
+				   &amp;ctask-&gt;sent)) {
+			ctask-&gt;unsol_count -= ctask-&gt;sent - start;
+			ctask-&gt;xmstate |= XMSTATE_UNS_DATA;
+			/* will continue with this ctask later.. */
+			if (conn-&gt;datadgst_en) {
+				crypto_digest_final(conn-&gt;data_tx_tfm,
+						(u8 *)&amp;dtask-&gt;digest);
+				debug_tcp("tx uns data fail 0x%x\n",
+					  dtask-&gt;digest);
+			}
+			return -EAGAIN;
+		}
+
+		BUG_ON(ctask-&gt;sent &gt; ctask-&gt;total_length);
+		ctask-&gt;unsol_count -= ctask-&gt;sent - start;
+
+		/*
+		 * XXX:we may run here with un-initial sendbuf.
+		 * so pass it
+		 */
+		if (conn-&gt;datadgst_en &amp;&amp; ctask-&gt;sent - start &gt; 0)
+			iscsi_buf_data_digest_update(conn, &amp;ctask-&gt;sendbuf);
+
+		if (!ctask-&gt;data_count)
+			break;
+		iscsi_buf_init_sg(&amp;ctask-&gt;sendbuf,
+				  &amp;ctask-&gt;sg[ctask-&gt;sg_count++]);
+	}
+	BUG_ON(ctask-&gt;unsol_count &lt; 0);
+
+	/*
+	 * Done with the Data-Out. Next, check if we need
+	 * to send another unsolicited Data-Out.
+	 */
+	if (ctask-&gt;unsol_count) {
+		if (conn-&gt;datadgst_en) {
+			if (iscsi_digest_final_send(conn, ctask,
+						    &amp;dtask-&gt;digestbuf,
+						    &amp;dtask-&gt;digest, 1)) {
+				debug_tcp("send uns digest 0x%x fail\n",
+					  dtask-&gt;digest);
+				return -EAGAIN;
+			}
+			debug_tcp("sending uns digest 0x%x, more uns\n",
+				  dtask-&gt;digest);
+		}
+		ctask-&gt;xmstate |= XMSTATE_UNS_INIT;
+		return 1;
+	}
+
+	if (conn-&gt;datadgst_en &amp;&amp; !(ctask-&gt;xmstate &amp; XMSTATE_W_PAD)) {
+		if (iscsi_digest_final_send(conn, ctask,
+					    &amp;dtask-&gt;digestbuf,
+					    &amp;dtask-&gt;digest, 1)) {
+			debug_tcp("send last uns digest 0x%x fail\n",
+				   dtask-&gt;digest);
+			return -EAGAIN;
+		}
+		debug_tcp("sending uns digest 0x%x\n",dtask-&gt;digest);
+	}
+
+	return 0;
+}
+
+static inline int
+handle_xmstate_sol_data(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_session *session = conn-&gt;session;
+	struct iscsi_r2t_info *r2t = ctask-&gt;r2t;
+	struct iscsi_data_task *dtask = r2t-&gt;dtask;
+	int left;
+
+	ctask-&gt;xmstate &amp;= ~XMSTATE_SOL_DATA;
+	ctask-&gt;dtask = dtask;
+
+	if (conn-&gt;datadgst_en) {
+		iscsi_data_digest_init(conn, ctask);
+		dtask-&gt;digest = 0;
+	}
+solicit_again:
+	/*
+	 * send Data-Out whitnin this R2T sequence.
+	 */
+	if (!r2t-&gt;data_count)
+		goto data_out_done;
+
+	if (iscsi_sendpage(conn, &amp;r2t-&gt;sendbuf, &amp;r2t-&gt;data_count, &amp;r2t-&gt;sent)) {
+		ctask-&gt;xmstate |= XMSTATE_SOL_DATA;
+		/* will continue with this ctask later.. */
+		if (conn-&gt;datadgst_en) {
+			crypto_digest_final(conn-&gt;data_tx_tfm,
+					  (u8 *)&amp;dtask-&gt;digest);
+			debug_tcp("r2t data send fail 0x%x\n", dtask-&gt;digest);
+		}
+		return -EAGAIN;
+	}
+
+	BUG_ON(r2t-&gt;data_count &lt; 0);
+	if (conn-&gt;datadgst_en)
+		iscsi_buf_data_digest_update(conn, &amp;r2t-&gt;sendbuf);
+
+	if (r2t-&gt;data_count) {
+		BUG_ON(ctask-&gt;sc-&gt;use_sg == 0);
+		if (!iscsi_buf_left(&amp;r2t-&gt;sendbuf)) {
+			BUG_ON(ctask-&gt;bad_sg == r2t-&gt;sg);
+			iscsi_buf_init_sg(&amp;r2t-&gt;sendbuf, r2t-&gt;sg);
+			r2t-&gt;sg += 1;
+		}
+		goto solicit_again;
+	}
+
+data_out_done:
+	/*
+	 * Done with this Data-Out. Next, check if we have
+	 * to send another Data-Out for this R2T.
+	 */
+	BUG_ON(r2t-&gt;data_length - r2t-&gt;sent &lt; 0);
+	left = r2t-&gt;data_length - r2t-&gt;sent;
+	if (left) {
+		if (conn-&gt;datadgst_en) {
+			if (iscsi_digest_final_send(conn, ctask,
+						    &amp;dtask-&gt;digestbuf,
+						    &amp;dtask-&gt;digest, 1)) {
+				debug_tcp("send r2t data digest 0x%x"
+					  "fail\n", dtask-&gt;digest);
+				return -EAGAIN;
+			}
+			debug_tcp("r2t data send digest 0x%x\n",
+				  dtask-&gt;digest);
+		}
+		iscsi_solicit_data_cont(conn, ctask, r2t, left);
+		ctask-&gt;xmstate |= XMSTATE_SOL_DATA;
+		ctask-&gt;xmstate &amp;= ~XMSTATE_SOL_HDR;
+		return 1;
+	}
+
+	/*
+	 * Done with this R2T. Check if there are more
+	 * outstanding R2Ts ready to be processed.
+	 */
+	BUG_ON(ctask-&gt;r2t_data_count - r2t-&gt;data_length &lt; 0);
+	if (conn-&gt;datadgst_en) {
+		if (iscsi_digest_final_send(conn, ctask, &amp;dtask-&gt;digestbuf,
+					    &amp;dtask-&gt;digest, 1)) {
+			debug_tcp("send last r2t data digest 0x%x"
+				  "fail\n", dtask-&gt;digest);
+			return -EAGAIN;
+		}
+		debug_tcp("r2t done dout digest 0x%x\n", dtask-&gt;digest);
+	}
+
+	ctask-&gt;r2t_data_count -= r2t-&gt;data_length;
+	ctask-&gt;r2t = NULL;
+	spin_lock_bh(&amp;session-&gt;lock);
+	__kfifo_put(ctask-&gt;r2tpool.queue, (void*)&amp;r2t, sizeof(void*));
+	spin_unlock_bh(&amp;session-&gt;lock);
+	if (__kfifo_get(ctask-&gt;r2tqueue, (void*)&amp;r2t, sizeof(void*))) {
+		ctask-&gt;r2t = r2t;
+		ctask-&gt;xmstate |= XMSTATE_SOL_DATA;
+		ctask-&gt;xmstate &amp;= ~XMSTATE_SOL_HDR;
+		return 1;
+	}
+
+	return 0;
+}
+
+static inline int
+handle_xmstate_w_pad(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	struct iscsi_data_task *dtask = ctask-&gt;dtask;
+	int sent;
+
+	ctask-&gt;xmstate &amp;= ~XMSTATE_W_PAD;
+	iscsi_buf_init_virt(&amp;ctask-&gt;sendbuf, (char*)&amp;ctask-&gt;pad,
+			    ctask-&gt;pad_count);
+	if (iscsi_sendpage(conn, &amp;ctask-&gt;sendbuf, &amp;ctask-&gt;pad_count, &amp;sent)) {
+		ctask-&gt;xmstate |= XMSTATE_W_PAD;
+		return -EAGAIN;
+	}
+
+	if (conn-&gt;datadgst_en) {
+		iscsi_buf_data_digest_update(conn, &amp;ctask-&gt;sendbuf);
+		/* imm data? */
+		if (!dtask) {
+			if (iscsi_digest_final_send(conn, ctask, &amp;ctask-&gt;immbuf,
+						    &amp;ctask-&gt;immdigest, 1)) {
+				debug_tcp("send padding digest 0x%x"
+					  "fail!\n", ctask-&gt;immdigest);
+				return -EAGAIN;
+			}
+			debug_tcp("done with padding, digest 0x%x\n",
+				  ctask-&gt;datadigest);
+		} else {
+			if (iscsi_digest_final_send(conn, ctask,
+						    &amp;dtask-&gt;digestbuf,
+						    &amp;dtask-&gt;digest, 1)) {
+				debug_tcp("send padding digest 0x%x"
+				          "fail\n", dtask-&gt;digest);
+				return -EAGAIN;
+			}
+			debug_tcp("done with padding, digest 0x%x\n",
+				  dtask-&gt;digest);
+		}
+	}
+
+	return 0;
+}
+
+static int
+iscsi_ctask_xmit(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)
+{
+	int rc = 0;
+
+	debug_scsi("ctask deq [cid %d xmstate %x itt 0x%x]\n",
+		conn-&gt;id, ctask-&gt;xmstate, ctask-&gt;itt);
+
+	/*
+	 * serialize with TMF AbortTask
+	 */
+	if (ctask-&gt;mtask)
+		return rc;
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_R_HDR) {
+		rc = handle_xmstate_r_hdr(conn, ctask);
+		return rc;
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_W_HDR) {
+		rc = handle_xmstate_w_hdr(conn, ctask);
+		if (rc)
+			return rc;
+	}
+
+	/* XXX: for data digest xmit recover */
+	if (ctask-&gt;xmstate &amp; XMSTATE_DATA_DIGEST) {
+		rc = handle_xmstate_data_digest(conn, ctask);
+		if (rc)
+			return rc;
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_IMM_DATA) {
+		rc = handle_xmstate_imm_data(conn, ctask);
+		if (rc)
+			return rc;
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_UNS_HDR) {
+		BUG_ON(!ctask-&gt;unsol_count);
+		ctask-&gt;xmstate &amp;= ~XMSTATE_UNS_HDR;
+unsolicit_head_again:
+		rc = handle_xmstate_uns_hdr(conn, ctask);
+		if (rc)
+			return rc;
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_UNS_DATA) {
+		rc = handle_xmstate_uns_data(conn, ctask);
+		if (rc == 1)
+			goto unsolicit_head_again;
+		else if (rc)
+			return rc;
+		goto done;
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_SOL_HDR) {
+		struct iscsi_r2t_info *r2t;
+
+		ctask-&gt;xmstate &amp;= ~XMSTATE_SOL_HDR;
+		ctask-&gt;xmstate |= XMSTATE_SOL_DATA;
+		if (!ctask-&gt;r2t)
+			__kfifo_get(ctask-&gt;r2tqueue, (void*)&amp;ctask-&gt;r2t,
+				    sizeof(void*));
+solicit_head_again:
+		r2t = ctask-&gt;r2t;
+
+		if (iscsi_sendhdr(conn, &amp;r2t-&gt;headbuf, r2t-&gt;data_count)) {
+			ctask-&gt;xmstate &amp;= ~XMSTATE_SOL_DATA;
+			ctask-&gt;xmstate |= XMSTATE_SOL_HDR;
+			return -EAGAIN;
+		}
+
+		debug_scsi("sol dout [dsn %d itt 0x%x dlen %d sent %d]\n",
+			r2t-&gt;solicit_datasn - 1, ctask-&gt;itt, r2t-&gt;data_count,
+			r2t-&gt;sent);
+	}
+
+	if (ctask-&gt;xmstate &amp; XMSTATE_SOL_DATA) {
+		rc = handle_xmstate_sol_data(conn, ctask);
+		if (rc == 1)
+			goto solicit_head_again;
+		if (rc)
+			return rc;
+	}
+
+done:
+	/*
+	 * Last thing to check is whether we need to send write
+	 * padding. Note that we check for xmstate equality, not just the bit.
+	 */
+	if (ctask-&gt;xmstate == XMSTATE_W_PAD)
+		rc = handle_xmstate_w_pad(conn, ctask);
+
+	return rc;
+}
+
+/**
+ * iscsi_data_xmit - xmit any command into the scheduled connection
+ * @conn: iscsi connection
+ *
+ * Notes:
+ *	The function can return -EAGAIN in which case the caller must
+ *	re-schedule it again later or recover. '0' return code means
+ *	successful xmit.
+ **/
+static int
+iscsi_data_xmit(struct iscsi_conn *conn)
+{
+	if (unlikely(conn-&gt;suspend_tx)) {
+		debug_tcp("conn %d Tx suspended!\n", conn-&gt;id);
+		return 0;
+	}
+
+	/*
+	 * Transmit in the following order:
+	 *
+	 * 1) un-finished xmit (ctask or mtask)
+	 * 2) immediate control PDUs
+	 * 3) write data
+	 * 4) SCSI commands
+	 * 5) non-immediate control PDUs
+	 *
+	 * No need to lock around __kfifo_get as long as
+	 * there's one producer and one consumer.
+	 */
+
+	BUG_ON(conn-&gt;ctask &amp;&amp; conn-&gt;mtask);
+
+	if (conn-&gt;ctask) {
+		if (iscsi_ctask_xmit(conn, conn-&gt;ctask))
+			goto again;
+		/* done with this in-progress ctask */
+		conn-&gt;ctask = NULL;
+	}
+	if (conn-&gt;mtask) {
+	        if (iscsi_mtask_xmit(conn, conn-&gt;mtask))
+		        goto again;
+		/* done with this in-progress mtask */
+		conn-&gt;mtask = NULL;
+	}
+
+	/* process immediate first */
+        if (unlikely(__kfifo_len(conn-&gt;immqueue))) {
+		struct iscsi_session *session = conn-&gt;session;
+	        while (__kfifo_get(conn-&gt;immqueue, (void*)&amp;conn-&gt;mtask,
+			           sizeof(void*))) {
+		        if (iscsi_mtask_xmit(conn, conn-&gt;mtask))
+			        goto again;
+
+		        if (conn-&gt;mtask-&gt;hdr.itt ==
+					cpu_to_be32(ISCSI_RESERVED_TAG)) {
+			        spin_lock_bh(&amp;session-&gt;lock);
+			        __kfifo_put(session-&gt;mgmtpool.queue,
+					    (void*)&amp;conn-&gt;mtask, sizeof(void*));
+			        spin_unlock_bh(&amp;session-&gt;lock);
+		        }
+	        }
+		/* done with this mtask */
+		conn-&gt;mtask = NULL;
+	}
+
+	/* process write queue */
+	while (__kfifo_get(conn-&gt;writequeue, (void*)&amp;conn-&gt;ctask,
+			   sizeof(void*))) {
+		if (iscsi_ctask_xmit(conn, conn-&gt;ctask))
+			goto again;
+	}
+
+	/* process command queue */
+	while (__kfifo_get(conn-&gt;xmitqueue, (void*)&amp;conn-&gt;ctask,
+			   sizeof(void*))) {
+		if (iscsi_ctask_xmit(conn, conn-&gt;ctask))
+			goto again;
+	}
+	/* done with this ctask */
+	conn-&gt;ctask = NULL;
+
+	/* process the rest control plane PDUs, if any */
+        if (unlikely(__kfifo_len(conn-&gt;mgmtqueue))) {
+		struct iscsi_session *session = conn-&gt;session;
+
+	        while (__kfifo_get(conn-&gt;mgmtqueue, (void*)&amp;conn-&gt;mtask,
+			           sizeof(void*))) {
+		        if (iscsi_mtask_xmit(conn, conn-&gt;mtask))
+			        goto again;
+
+		        if (conn-&gt;mtask-&gt;hdr.itt ==
+					cpu_to_be32(ISCSI_RESERVED_TAG)) {
+			        spin_lock_bh(&amp;session-&gt;lock);
+			        __kfifo_put(session-&gt;mgmtpool.queue,
+					    (void*)&amp;conn-&gt;mtask,
+				            sizeof(void*));
+			        spin_unlock_bh(&amp;session-&gt;lock);
+		        }
+	        }
+		/* done with this mtask */
+		conn-&gt;mtask = NULL;
+	}
+
+	return 0;
+
+again:
+	if (unlikely(conn-&gt;suspend_tx))
+		return 0;
+
+	return -EAGAIN;
+}
+
+static void
+iscsi_xmitworker(void *data)
+{
+	struct iscsi_conn *conn = data;
+
+	/*
+	 * serialize Xmit worker on a per-connection basis.
+	 */
+	down(&amp;conn-&gt;xmitsema);
+	if (iscsi_data_xmit(conn))
+		schedule_work(&amp;conn-&gt;xmitwork);
+	up(&amp;conn-&gt;xmitsema);
+}
+
+#define FAILURE_BAD_HOST		1
+#define FAILURE_SESSION_FAILED		2
+#define FAILURE_SESSION_FREED		3
+#define FAILURE_WINDOW_CLOSED		4
+#define FAILURE_SESSION_TERMINATE	5
+
+static int
+iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
+{
+	struct Scsi_Host *host;
+	int reason = 0;
+	struct iscsi_session *session;
+	struct iscsi_conn *conn = NULL;
+	struct iscsi_cmd_task *ctask = NULL;
+
+	sc-&gt;scsi_done = done;
+	sc-&gt;result = 0;
+
+	host = sc-&gt;device-&gt;host;
+	session = iscsi_hostdata(host-&gt;hostdata);
+	BUG_ON(host != session-&gt;host);
+
+	spin_lock(&amp;session-&gt;lock);
+
+	if (session-&gt;state != ISCSI_STATE_LOGGED_IN) {
+		if (session-&gt;state == ISCSI_STATE_FAILED) {
+			reason = FAILURE_SESSION_FAILED;
+			goto reject;
+		} else if (session-&gt;state == ISCSI_STATE_TERMINATE) {
+			reason = FAILURE_SESSION_TERMINATE;
+			goto fault;
+		}
+		reason = FAILURE_SESSION_FREED;
+		goto fault;
+	}
+
+	/*
+	 * Check for iSCSI window and take care of CmdSN wrap-around
+	 */
+	if ((int)(session-&gt;max_cmdsn - session-&gt;cmdsn) &lt; 0) {
+		reason = FAILURE_WINDOW_CLOSED;
+		goto reject;
+	}
+
+	conn = session-&gt;leadconn;
+
+	__kfifo_get(session-&gt;cmdpool.queue, (void*)&amp;ctask, sizeof(void*));
+	BUG_ON(ctask-&gt;sc);
+
+	sc-&gt;SCp.phase = session-&gt;age;
+	sc-&gt;SCp.ptr = (char*)ctask;
+	iscsi_cmd_init(conn, ctask, sc);
+
+	__kfifo_put(conn-&gt;xmitqueue, (void*)&amp;ctask, sizeof(void*));
+	debug_scsi(
+	       "ctask enq [%s cid %d sc %lx itt 0x%x len %d cmdsn %d win %d]\n",
+		sc-&gt;sc_data_direction == DMA_TO_DEVICE ? "write" : "read",
+		conn-&gt;id, (long)sc, ctask-&gt;itt, sc-&gt;request_bufflen,
+		session-&gt;cmdsn, session-&gt;max_cmdsn - session-&gt;exp_cmdsn + 1);
+	spin_unlock(&amp;session-&gt;lock);
+
+        if (!in_interrupt() &amp;&amp; !down_trylock(&amp;conn-&gt;xmitsema)) {
+		spin_unlock_irq(host-&gt;host_lock);
+		if (iscsi_data_xmit(conn))
+			schedule_work(&amp;conn-&gt;xmitwork);
+		up(&amp;conn-&gt;xmitsema);
+		spin_lock_irq(host-&gt;host_lock);
+	} else
+		schedule_work(&amp;conn-&gt;xmitwork);
+
+	return 0;
+
+reject:
+	spin_unlock(&amp;session-&gt;lock);
+	debug_scsi("cmd 0x%x rejected (%d)\n", sc-&gt;cmnd[0], reason);
+	return SCSI_MLQUEUE_HOST_BUSY;
+
+fault:
+	spin_unlock(&amp;session-&gt;lock);
+	printk(KERN_ERR "iscsi_tcp: cmd 0x%x is not queued (%d)\n",
+	       sc-&gt;cmnd[0], reason);
+	sc-&gt;sense_buffer[0] = 0x70;
+	sc-&gt;sense_buffer[2] = NOT_READY;
+	sc-&gt;sense_buffer[7] = 0x6;
+	sc-&gt;sense_buffer[12] = 0x08;
+	sc-&gt;sense_buffer[13] = 0x00;
+	sc-&gt;result = (DID_NO_CONNECT &lt;&lt; 16);
+	sc-&gt;resid = sc-&gt;request_bufflen;
+	sc-&gt;scsi_done(sc);
+	return 0;
+}
+
+static int
+iscsi_pool_init(struct iscsi_queue *q, int max, void ***items, int item_size)
+{
+	int i;
+
+	*items = kmalloc(max * sizeof(void*), GFP_KERNEL);
+	if (*items == NULL)
+		return -ENOMEM;
+
+	q-&gt;max = max;
+	q-&gt;pool = kmalloc(max * sizeof(void*), GFP_KERNEL);
+	if (q-&gt;pool == NULL) {
+		kfree(*items);
+		return -ENOMEM;
+	}
+
+	q-&gt;queue = kfifo_init((void*)q-&gt;pool, max * sizeof(void*),
+			      GFP_KERNEL, NULL);
+	if (q-&gt;queue == ERR_PTR(-ENOMEM)) {
+		kfree(q-&gt;pool);
+		kfree(*items);
+		return -ENOMEM;
+	}
+
+	for (i = 0; i &lt; max; i++) {
+		q-&gt;pool[i] = kmalloc(item_size, GFP_KERNEL);
+		if (q-&gt;pool[i] == NULL) {
+			int j;
+
+			for (j = 0; j &lt; i; j++)
+				kfree(q-&gt;pool[j]);
+
+			kfifo_free(q-&gt;queue);
+			kfree(q-&gt;pool);
+			kfree(*items);
+			return -ENOMEM;
+		}
+		memset(q-&gt;pool[i], 0, item_size);
+		(*items)[i] = q-&gt;pool[i];
+		__kfifo_put(q-&gt;queue, (void*)&amp;q-&gt;pool[i], sizeof(void*));
+	}
+	return 0;
+}
+
+static void
+iscsi_pool_free(struct iscsi_queue *q, void **items)
+{
+	int i;
+
+	for (i = 0; i &lt; q-&gt;max; i++)
+		kfree(items[i]);
+	kfree(q-&gt;pool);
+	kfree(items);
+}
+
+static iscsi_connh_t
+iscsi_conn_create(iscsi_sessionh_t sessionh, uint32_t conn_idx)
+{
+	struct iscsi_session *session = iscsi_ptr(sessionh);
+	struct iscsi_conn *conn = NULL;
+
+	conn = kmalloc(sizeof(struct iscsi_conn), GFP_KERNEL);
+	if (conn == NULL)
+		goto conn_alloc_fail;
+	memset(conn, 0, sizeof(struct iscsi_conn));
+
+	conn-&gt;c_stage = ISCSI_CONN_INITIAL_STAGE;
+	conn-&gt;in_progress = IN_PROGRESS_WAIT_HEADER;
+	conn-&gt;id = conn_idx;
+	conn-&gt;exp_statsn = 0;
+	conn-&gt;tmabort_state = TMABORT_INITIAL;
+
+	/* initial operational parameters */
+	conn-&gt;hdr_size = sizeof(struct iscsi_hdr);
+	conn-&gt;data_size = DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH;
+	conn-&gt;max_recv_dlength = DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH;
+
+	spin_lock_init(&amp;conn-&gt;lock);
+
+	/* initialize general xmit PDU commands queue */
+	conn-&gt;xmitqueue = kfifo_alloc(session-&gt;cmds_max * sizeof(void*),
+					GFP_KERNEL, NULL);
+	if (conn-&gt;xmitqueue == ERR_PTR(-ENOMEM))
+		goto xmitqueue_alloc_fail;
+
+	/* initialize write response PDU commands queue */
+	conn-&gt;writequeue = kfifo_alloc(session-&gt;cmds_max * sizeof(void*),
+					GFP_KERNEL, NULL);
+	if (conn-&gt;writequeue == ERR_PTR(-ENOMEM))
+		goto writequeue_alloc_fail;
+
+	/* initialize general immediate &amp; non-immediate PDU commands queue */
+	conn-&gt;immqueue = kfifo_alloc(session-&gt;mgmtpool_max * sizeof(void*),
+			                GFP_KERNEL, NULL);
+	if (conn-&gt;immqueue == ERR_PTR(-ENOMEM))
+		goto immqueue_alloc_fail;
+
+	conn-&gt;mgmtqueue = kfifo_alloc(session-&gt;mgmtpool_max * sizeof(void*),
+			                GFP_KERNEL, NULL);
+	if (conn-&gt;mgmtqueue == ERR_PTR(-ENOMEM))
+		goto mgmtqueue_alloc_fail;
+
+	INIT_WORK(&amp;conn-&gt;xmitwork, iscsi_xmitworker, conn);
+
+	/* allocate login_mtask used for the login/text sequences */
+	spin_lock_bh(&amp;session-&gt;lock);
+	if (!__kfifo_get(session-&gt;mgmtpool.queue,
+                         (void*)&amp;conn-&gt;login_mtask,
+			 sizeof(void*))) {
+		spin_unlock_bh(&amp;session-&gt;lock);
+		goto login_mtask_alloc_fail;
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	/* allocate initial PDU receive place holder */
+	if (conn-&gt;data_size &lt;= PAGE_SIZE)
+		conn-&gt;data = kmalloc(conn-&gt;data_size, GFP_KERNEL);
+	else
+		conn-&gt;data = (void*)__get_free_pages(GFP_KERNEL,
+					get_order(conn-&gt;data_size));
+	if (!conn-&gt;data)
+		goto max_recv_dlenght_alloc_fail;
+
+	init_timer(&amp;conn-&gt;tmabort_timer);
+	init_MUTEX(&amp;conn-&gt;xmitsema);
+	init_waitqueue_head(&amp;conn-&gt;ehwait);
+
+	return iscsi_handle(conn);
+
+max_recv_dlenght_alloc_fail:
+	spin_lock_bh(&amp;session-&gt;lock);
+	__kfifo_put(session-&gt;mgmtpool.queue, (void*)&amp;conn-&gt;login_mtask,
+		    sizeof(void*));
+	spin_unlock_bh(&amp;session-&gt;lock);
+login_mtask_alloc_fail:
+	kfifo_free(conn-&gt;mgmtqueue);
+mgmtqueue_alloc_fail:
+	kfifo_free(conn-&gt;immqueue);
+immqueue_alloc_fail:
+	kfifo_free(conn-&gt;writequeue);
+writequeue_alloc_fail:
+	kfifo_free(conn-&gt;xmitqueue);
+xmitqueue_alloc_fail:
+	kfree(conn);
+conn_alloc_fail:
+	return iscsi_handle(NULL);
+}
+
+static void
+iscsi_conn_destroy(iscsi_connh_t connh)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	struct iscsi_session *session = conn-&gt;session;
+
+	down(&amp;conn-&gt;xmitsema);
+	set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+	if (conn-&gt;c_stage == ISCSI_CONN_INITIAL_STAGE &amp;&amp; conn-&gt;sock) {
+		struct sock *sk = conn-&gt;sock-&gt;sk;
+
+		/*
+		 * conn_start() has never been called!
+		 * need to cleanup the socket.
+		 */
+		write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+		set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_rx);
+		write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+
+		sock_hold(conn-&gt;sock-&gt;sk);
+		iscsi_conn_restore_callbacks(conn);
+		sock_put(conn-&gt;sock-&gt;sk);
+		sock_release(conn-&gt;sock);
+		conn-&gt;sock = NULL;
+	}
+
+	spin_lock_bh(&amp;session-&gt;lock);
+	conn-&gt;c_stage = ISCSI_CONN_CLEANUP_WAIT;
+	if (session-&gt;leadconn == conn) {
+		/*
+		 * leading connection? then give up on recovery.
+		 */
+		session-&gt;state = ISCSI_STATE_TERMINATE;
+		wake_up(&amp;conn-&gt;ehwait);
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	up(&amp;conn-&gt;xmitsema);
+
+	/*
+	 * Block until all in-progress commands for this connection
+	 * time out or fail.
+	 */
+	for (;;) {
+		spin_lock_bh(&amp;conn-&gt;lock);
+		if (!session-&gt;host-&gt;host_busy) { /* OK for ERL == 0 */
+			spin_unlock_bh(&amp;conn-&gt;lock);
+			break;
+		}
+		spin_unlock_bh(&amp;conn-&gt;lock);
+		msleep_interruptible(500);
+		printk("conn_destroy(): host_busy %d host_failed %d\n",
+			session-&gt;host-&gt;host_busy, session-&gt;host-&gt;host_failed);
+		/*
+		 * force eh_abort() to unblock
+		 */
+		wake_up(&amp;conn-&gt;ehwait);
+	}
+
+	/* now free crypto */
+	if (conn-&gt;hdrdgst_en || conn-&gt;datadgst_en) {
+		if (conn-&gt;tx_tfm)
+			crypto_free_tfm(conn-&gt;tx_tfm);
+		if (conn-&gt;rx_tfm)
+			crypto_free_tfm(conn-&gt;rx_tfm);
+		if (conn-&gt;data_tx_tfm)
+			crypto_free_tfm(conn-&gt;data_tx_tfm);
+		if (conn-&gt;data_rx_tfm)
+			crypto_free_tfm(conn-&gt;data_rx_tfm);
+	}
+
+	/* free conn-&gt;data, size = MaxRecvDataSegmentLength */
+	if (conn-&gt;data_size &lt;= PAGE_SIZE)
+		kfree(conn-&gt;data);
+	else
+		free_pages((unsigned long)conn-&gt;data,
+					get_order(conn-&gt;data_size));
+
+	spin_lock_bh(&amp;session-&gt;lock);
+	__kfifo_put(session-&gt;mgmtpool.queue, (void*)&amp;conn-&gt;login_mtask,
+		    sizeof(void*));
+	list_del(&amp;conn-&gt;item);
+	if (list_empty(&amp;session-&gt;connections))
+		session-&gt;leadconn = NULL;
+	if (session-&gt;leadconn &amp;&amp; session-&gt;leadconn == conn)
+		session-&gt;leadconn = container_of(session-&gt;connections.next,
+			struct iscsi_conn, item);
+
+	if (session-&gt;leadconn == NULL)
+		/* none connections exits.. reset sequencing */
+		session-&gt;cmdsn = session-&gt;max_cmdsn = session-&gt;exp_cmdsn = 1;
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	kfifo_free(conn-&gt;xmitqueue);
+	kfifo_free(conn-&gt;writequeue);
+	kfifo_free(conn-&gt;immqueue);
+	kfifo_free(conn-&gt;mgmtqueue);
+	kfree(conn);
+}
+
+static int
+iscsi_conn_bind(iscsi_sessionh_t sessionh, iscsi_connh_t connh,
+		uint32_t transport_fd, int is_leading)
+{
+	struct iscsi_session *session = iscsi_ptr(sessionh);
+	struct iscsi_conn *tmp = ERR_PTR(-EEXIST), *conn = iscsi_ptr(connh);
+	struct sock *sk;
+	struct socket *sock;
+	int err;
+
+	/* lookup for existing socket */
+	sock = sockfd_lookup(transport_fd, &amp;err);
+	if (!sock) {
+		printk(KERN_ERR "iscsi_tcp: sockfd_lookup failed %d\n", err);
+		return -EEXIST;
+	}
+
+	/* lookup for existing connection */
+	spin_lock_bh(&amp;session-&gt;lock);
+	list_for_each_entry(tmp, &amp;session-&gt;connections, item) {
+		if (tmp == conn) {
+			if (conn-&gt;c_stage != ISCSI_CONN_STOPPED ||
+			    conn-&gt;stop_stage == STOP_CONN_TERM) {
+				printk(KERN_ERR "iscsi_tcp: can't bind "
+				       "non-stopped connection (%d:%d)\n",
+				       conn-&gt;c_stage, conn-&gt;stop_stage);
+				spin_unlock_bh(&amp;session-&gt;lock);
+				return -EIO;
+			}
+			break;
+		}
+	}
+	if (tmp != conn) {
+		/* bind new iSCSI connection to session */
+		conn-&gt;session = session;
+
+		list_add(&amp;conn-&gt;item, &amp;session-&gt;connections);
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	if (conn-&gt;stop_stage != STOP_CONN_SUSPEND) {
+		/* bind iSCSI connection and socket */
+		conn-&gt;sock = sock;
+
+		/* setup Socket parameters */
+		sk = sock-&gt;sk;
+		sk-&gt;sk_reuse = 1;
+		sk-&gt;sk_sndtimeo = 15 * HZ; /* FIXME: make it configurable */
+		sk-&gt;sk_allocation = GFP_ATOMIC;
+
+		/* FIXME: disable Nagle's algorithm */
+
+		/*
+		 * Intercept TCP callbacks for sendfile like receive
+		 * processing.
+		 */
+		iscsi_conn_set_callbacks(conn);
+
+		/*
+		 * set receive state machine into initial state
+		 */
+		conn-&gt;in_progress = IN_PROGRESS_WAIT_HEADER;
+	}
+
+	if (is_leading)
+		session-&gt;leadconn = conn;
+
+	/*
+	 * Unblock xmitworker(), Login Phase will pass through.
+	 */
+	clear_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_rx);
+	clear_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+
+	return 0;
+}
+
+static int
+iscsi_conn_start(iscsi_connh_t connh)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	struct iscsi_session *session = conn-&gt;session;
+	struct sock *sk;
+
+	/* FF phase warming up... */
+
+	if (session == NULL) {
+		printk(KERN_ERR "iscsi_tcp: can't start unbound connection\n");
+		return -EPERM;
+	}
+
+	sk = conn-&gt;sock-&gt;sk;
+
+	write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+	spin_lock_bh(&amp;session-&gt;lock);
+	conn-&gt;c_stage = ISCSI_CONN_STARTED;
+	session-&gt;state = ISCSI_STATE_LOGGED_IN;
+
+	switch(conn-&gt;stop_stage) {
+	case STOP_CONN_RECOVER:
+		/*
+		 * unblock eh_abort() if it is blocked. re-try all
+		 * commands after successful recovery
+		 */
+		session-&gt;conn_cnt++;
+		conn-&gt;stop_stage = 0;
+		conn-&gt;tmabort_state = TMABORT_INITIAL;
+		session-&gt;age++;
+		wake_up(&amp;conn-&gt;ehwait);
+		break;
+	case STOP_CONN_TERM:
+		session-&gt;conn_cnt++;
+		conn-&gt;stop_stage = 0;
+		break;
+	case STOP_CONN_SUSPEND:
+		conn-&gt;stop_stage = 0;
+		clear_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_rx);
+		clear_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+		break;
+	default:
+		break;
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+	write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+
+	return 0;
+}
+
+static void
+iscsi_conn_stop(iscsi_connh_t connh, int flag)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	struct iscsi_session *session = conn-&gt;session;
+	struct sock *sk;
+	unsigned long flags;
+
+	BUG_ON(!conn-&gt;sock);
+	sk = conn-&gt;sock-&gt;sk;
+	write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+	set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_rx);
+	write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+
+	down(&amp;conn-&gt;xmitsema);
+
+	spin_lock_irqsave(session-&gt;host-&gt;host_lock, flags);
+	spin_lock(&amp;session-&gt;lock);
+	conn-&gt;stop_stage = flag;
+	conn-&gt;c_stage = ISCSI_CONN_STOPPED;
+	set_bit(SUSPEND_BIT, &amp;conn-&gt;suspend_tx);
+
+	if (flag != STOP_CONN_SUSPEND)
+		session-&gt;conn_cnt--;
+
+	if (session-&gt;conn_cnt == 0 || session-&gt;leadconn == conn)
+		session-&gt;state = ISCSI_STATE_FAILED;
+
+	spin_unlock(&amp;session-&gt;lock);
+	spin_unlock_irqrestore(session-&gt;host-&gt;host_lock, flags);
+
+	if (flag == STOP_CONN_TERM || flag == STOP_CONN_RECOVER) {
+		struct iscsi_cmd_task *ctask;
+		struct iscsi_mgmt_task *mtask;
+
+		/*
+		 * Socket must go now.
+		 */
+		sock_hold(conn-&gt;sock-&gt;sk);
+		iscsi_conn_restore_callbacks(conn);
+		sock_put(conn-&gt;sock-&gt;sk);
+
+		/*
+		 * flush xmit queues.
+		 */
+		spin_lock_bh(&amp;session-&gt;lock);
+		while (__kfifo_get(conn-&gt;writequeue, (void*)&amp;ctask,
+			    sizeof(void*)) ||
+			__kfifo_get(conn-&gt;xmitqueue, (void*)&amp;ctask,
+			    sizeof(void*))) {
+			struct iscsi_r2t_info *r2t;
+
+			/*
+			 * flush ctask's r2t queues
+			 */
+			while (__kfifo_get(ctask-&gt;r2tqueue, (void*)&amp;r2t,
+				sizeof(void*)))
+				__kfifo_put(ctask-&gt;r2tpool.queue, (void*)&amp;r2t,
+					    sizeof(void*));
+
+			spin_unlock_bh(&amp;session-&gt;lock);
+			local_bh_disable();
+			iscsi_ctask_cleanup(conn, ctask);
+			local_bh_enable();
+			spin_lock_bh(&amp;session-&gt;lock);
+		}
+		conn-&gt;ctask = NULL;
+		while (__kfifo_get(conn-&gt;immqueue, (void*)&amp;mtask,
+			   sizeof(void*)) ||
+			__kfifo_get(conn-&gt;mgmtqueue, (void*)&amp;mtask,
+			   sizeof(void*))) {
+			__kfifo_put(session-&gt;mgmtpool.queue,
+				    (void*)&amp;mtask, sizeof(void*));
+		}
+		conn-&gt;mtask = NULL;
+		spin_unlock_bh(&amp;session-&gt;lock);
+
+		/*
+		 * release socket only after we stopped data_xmit()
+		 * activity and flushed all outstandings
+		 */
+		sock_release(conn-&gt;sock);
+		conn-&gt;sock = NULL;
+
+		/*
+		 * for connection level recovery we should not calculate
+		 * header digest. conn-&gt;hdr_size used for optimization
+		 * in hdr_extract() and will be re-negotiated at
+		 * set_param() time.
+		 */
+		if (flag == STOP_CONN_RECOVER)
+			conn-&gt;hdr_size = sizeof(struct iscsi_hdr);
+	}
+	up(&amp;conn-&gt;xmitsema);
+}
+
+static int
+iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
+			char *data, uint32_t data_size)
+{
+	struct iscsi_session *session = conn-&gt;session;
+	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
+	struct iscsi_mgmt_task *mtask;
+
+	spin_lock_bh(&amp;session-&gt;lock);
+	if (session-&gt;state == ISCSI_STATE_TERMINATE) {
+		spin_unlock_bh(&amp;session-&gt;lock);
+		return -EPERM;
+	}
+	if (hdr-&gt;opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) ||
+	    hdr-&gt;opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
+		/*
+		 * Login and Text are sent serially, in
+		 * request-followed-by-response sequence.
+		 * Same mtask can be used. Same ITT must be used.
+		 * Note that login_mtask is preallocated at conn_create().
+		 */
+		mtask = conn-&gt;login_mtask;
+	else {
+	        BUG_ON(conn-&gt;c_stage == ISCSI_CONN_INITIAL_STAGE);
+	        BUG_ON(conn-&gt;c_stage == ISCSI_CONN_STOPPED);
+
+		if (!__kfifo_get(session-&gt;mgmtpool.queue,
+				 (void*)&amp;mtask, sizeof(void*))) {
+			spin_unlock_bh(&amp;session-&gt;lock);
+			return -ENOSPC;
+		}
+	}
+
+	/*
+	 * pre-format CmdSN and ExpStatSN for outgoing PDU.
+	 */
+	if (hdr-&gt;itt != cpu_to_be32(ISCSI_RESERVED_TAG)) {
+		hdr-&gt;itt = mtask-&gt;itt | (conn-&gt;id &lt;&lt; CID_SHIFT) |
+			   (session-&gt;age &lt;&lt; AGE_SHIFT);
+		nop-&gt;cmdsn = cpu_to_be32(session-&gt;cmdsn);
+		if (conn-&gt;c_stage == ISCSI_CONN_STARTED &amp;&amp;
+		    !(hdr-&gt;opcode &amp; ISCSI_OP_IMMEDIATE))
+			session-&gt;cmdsn++;
+	} else
+		/* do not advance CmdSN */
+		nop-&gt;cmdsn = cpu_to_be32(session-&gt;cmdsn);
+
+	nop-&gt;exp_statsn = cpu_to_be32(conn-&gt;exp_statsn);
+
+	memcpy(&amp;mtask-&gt;hdr, hdr, sizeof(struct iscsi_hdr));
+
+	if (conn-&gt;c_stage == ISCSI_CONN_INITIAL_STAGE ||
+	    conn-&gt;stop_stage == STOP_CONN_RECOVER)
+		iscsi_buf_init_virt(&amp;mtask-&gt;headbuf, (char*)&amp;mtask-&gt;hdr,
+				    sizeof(struct iscsi_hdr));
+	else
+		/* this will update header digest */
+		iscsi_buf_init_hdr(conn, &amp;mtask-&gt;headbuf, (char*)&amp;mtask-&gt;hdr,
+				    (u8 *)mtask-&gt;hdrext);
+
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	if (data_size) {
+		memcpy(mtask-&gt;data, data, data_size);
+		mtask-&gt;data_count = data_size;
+	} else
+		mtask-&gt;data_count = 0;
+
+	mtask-&gt;xmstate = XMSTATE_IMM_HDR;
+
+	if (mtask-&gt;data_count) {
+		iscsi_buf_init_iov(&amp;mtask-&gt;sendbuf, (char*)mtask-&gt;data,
+				    mtask-&gt;data_count);
+	}
+
+	debug_scsi("mgmtpdu [op 0x%x hdr-&gt;itt 0x%x datalen %d]\n",
+		   hdr-&gt;opcode, hdr-&gt;itt, data_size);
+
+	/*
+	 * since send_pdu() could be called at least from two contexts,
+	 * we need to serialize __kfifo_put, so we don't have to take
+	 * additional lock on fast data-path
+	 */
+        if (hdr-&gt;opcode &amp; ISCSI_OP_IMMEDIATE)
+	        __kfifo_put(conn-&gt;immqueue, (void*)&amp;mtask, sizeof(void*));
+	else
+	        __kfifo_put(conn-&gt;mgmtqueue, (void*)&amp;mtask, sizeof(void*));
+
+	schedule_work(&amp;conn-&gt;xmitwork);
+
+	return 0;
+}
+
+static int
+iscsi_eh_host_reset(struct scsi_cmnd *sc)
+{
+	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc-&gt;SCp.ptr;
+	struct iscsi_conn *conn = ctask-&gt;conn;
+	struct iscsi_session *session = conn-&gt;session;
+
+	spin_lock_bh(&amp;session-&gt;lock);
+	if (session-&gt;state == ISCSI_STATE_TERMINATE) {
+		debug_scsi("failing host reset: session terminated "
+			   "[CID %d age %d]", conn-&gt;id, session-&gt;age);
+		spin_unlock_bh(&amp;session-&gt;lock);
+		return FAILED;
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	debug_scsi("failing connection CID %d due to SCSI host reset "
+		   "[itt 0x%x age %d]", conn-&gt;id, ctask-&gt;itt,
+		   session-&gt;age);
+	iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+
+	return SUCCESS;
+}
+
+static void
+iscsi_tmabort_timedout(unsigned long data)
+{
+	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)data;
+	struct iscsi_conn *conn = ctask-&gt;conn;
+	struct iscsi_session *session = conn-&gt;session;
+
+	spin_lock(&amp;session-&gt;lock);
+	if (conn-&gt;tmabort_state == TMABORT_INITIAL) {
+		__kfifo_put(session-&gt;mgmtpool.queue,
+				(void*)&amp;ctask-&gt;mtask, sizeof(void*));
+		conn-&gt;tmabort_state = TMABORT_TIMEDOUT;
+		debug_scsi("tmabort timedout [sc %lx itt 0x%x]\n",
+			(long)ctask-&gt;sc, ctask-&gt;itt);
+		/* unblock eh_abort() */
+		wake_up(&amp;conn-&gt;ehwait);
+	}
+	spin_unlock(&amp;session-&gt;lock);
+}
+
+static int
+iscsi_eh_abort(struct scsi_cmnd *sc)
+{
+	int rc;
+	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc-&gt;SCp.ptr;
+	struct iscsi_conn *conn = ctask-&gt;conn;
+	struct iscsi_session *session = conn-&gt;session;
+
+	conn-&gt;eh_abort_cnt++;
+	debug_scsi("aborting [sc %lx itt 0x%x]\n", (long)sc, ctask-&gt;itt);
+
+	/*
+	 * two cases for ERL=0 here:
+	 *
+	 * 1) connection-level failure;
+	 * 2) recovery due protocol error;
+	 */
+	down(&amp;conn-&gt;xmitsema);
+	spin_lock_bh(&amp;session-&gt;lock);
+	if (session-&gt;state != ISCSI_STATE_LOGGED_IN) {
+		if (session-&gt;state == ISCSI_STATE_TERMINATE) {
+			spin_unlock_bh(&amp;session-&gt;lock);
+			up(&amp;conn-&gt;xmitsema);
+			goto failed;
+		}
+		spin_unlock_bh(&amp;session-&gt;lock);
+	} else {
+		struct iscsi_tm *hdr = &amp;conn-&gt;tmhdr;
+
+		/*
+		 * Still LOGGED_IN...
+		 */
+
+		if (!ctask-&gt;sc || sc-&gt;SCp.phase != session-&gt;age) {
+			/*
+			 * 1) ctask completed before time out. But session
+			 *    is still ok =&gt; Happy Retry.
+			 * 2) session was re-open during time out of ctask.
+			 */
+			spin_unlock_bh(&amp;session-&gt;lock);
+			up(&amp;conn-&gt;xmitsema);
+			goto success;
+		}
+		conn-&gt;tmabort_state = TMABORT_INITIAL;
+		spin_unlock_bh(&amp;session-&gt;lock);
+
+		/*
+		 * ctask timed out but session is OK
+		 * ERL=0 requires task mgmt abort to be issued on each
+		 * failed command. requests must be serialized.
+		 */
+		memset(hdr, 0, sizeof(struct iscsi_tm));
+		hdr-&gt;opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
+		hdr-&gt;flags = ISCSI_TM_FUNC_ABORT_TASK;
+		hdr-&gt;flags |= ISCSI_FLAG_CMD_FINAL;
+		memcpy(hdr-&gt;lun, ctask-&gt;hdr.lun, sizeof(hdr-&gt;lun));
+		hdr-&gt;rtt = ctask-&gt;hdr.itt;
+		hdr-&gt;refcmdsn = ctask-&gt;hdr.cmdsn;
+
+		rc = iscsi_conn_send_generic(conn, (struct iscsi_hdr *)hdr,
+					     NULL, 0);
+		if (rc) {
+			iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+			debug_scsi("abort sent failure [itt 0x%x]", ctask-&gt;itt);
+		} else {
+			struct iscsi_r2t_info *r2t;
+
+			/*
+			 * TMF abort vs. TMF response race logic
+			 */
+			spin_lock_bh(&amp;session-&gt;lock);
+			ctask-&gt;mtask = (struct iscsi_mgmt_task *)
+				session-&gt;mgmt_cmds[(hdr-&gt;itt &amp; ITT_MASK) -
+							ISCSI_MGMT_ITT_OFFSET];
+			/*
+			 * have to flush r2tqueue to avoid r2t leaks
+			 */
+			while (__kfifo_get(ctask-&gt;r2tqueue, (void*)&amp;r2t,
+				sizeof(void*))) {
+				__kfifo_put(ctask-&gt;r2tpool.queue, (void*)&amp;r2t,
+					sizeof(void*));
+			}
+			if (conn-&gt;tmabort_state == TMABORT_INITIAL) {
+				conn-&gt;tmfcmd_pdus_cnt++;
+				conn-&gt;tmabort_timer.expires = 3*HZ + jiffies;
+				conn-&gt;tmabort_timer.function =
+						iscsi_tmabort_timedout;
+				conn-&gt;tmabort_timer.data = (unsigned long)ctask;
+				add_timer(&amp;conn-&gt;tmabort_timer);
+				debug_scsi("abort sent [itt 0x%x]", ctask-&gt;itt);
+			} else {
+				if (!ctask-&gt;sc ||
+				    conn-&gt;tmabort_state == TMABORT_SUCCESS) {
+					conn-&gt;tmabort_state = TMABORT_INITIAL;
+					spin_unlock_bh(&amp;session-&gt;lock);
+					up(&amp;conn-&gt;xmitsema);
+					goto success;
+				}
+				conn-&gt;tmabort_state = TMABORT_INITIAL;
+				iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+			}
+			spin_unlock_bh(&amp;session-&gt;lock);
+		}
+	}
+	up(&amp;conn-&gt;xmitsema);
+
+
+	/*
+	 * block eh thread until:
+	 *
+	 * 1) abort response;
+	 * 2) abort timeout;
+	 * 3) session re-opened;
+	 * 4) session terminated;
+	 */
+	for (;;) {
+		int p_state = session-&gt;state;
+
+		rc = wait_event_interruptible(conn-&gt;ehwait,
+			(p_state == ISCSI_STATE_LOGGED_IN ?
+			 (session-&gt;state == ISCSI_STATE_TERMINATE ||
+			  conn-&gt;tmabort_state != TMABORT_INITIAL) :
+			 (session-&gt;state == ISCSI_STATE_TERMINATE ||
+			  session-&gt;state == ISCSI_STATE_LOGGED_IN)));
+		if (rc) {
+			/* shutdown.. */
+			session-&gt;state = ISCSI_STATE_TERMINATE;
+			goto failed;
+		}
+
+		if (signal_pending(current))
+			flush_signals(current);
+
+		if (session-&gt;state == ISCSI_STATE_TERMINATE)
+			goto failed;
+
+		spin_lock_bh(&amp;session-&gt;lock);
+		if (sc-&gt;SCp.phase == session-&gt;age &amp;&amp;
+		   (conn-&gt;tmabort_state == TMABORT_TIMEDOUT ||
+		    conn-&gt;tmabort_state == TMABORT_FAILED)) {
+			conn-&gt;tmabort_state = TMABORT_INITIAL;
+			if (!ctask-&gt;sc) {
+				/*
+				 * ctask completed before tmf abort response or
+				 * time out.
+				 * But session is still ok =&gt; Happy Retry.
+				 */
+				spin_unlock_bh(&amp;session-&gt;lock);
+				break;
+			}
+			spin_unlock_bh(&amp;session-&gt;lock);
+			iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+			continue;
+		}
+		spin_unlock_bh(&amp;session-&gt;lock);
+		break;
+	}
+
+success:
+	debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, ctask-&gt;itt);
+	rc = SUCCESS;
+	goto exit;
+
+failed:
+	debug_scsi("abort failed [sc %lx itt 0x%x]\n", (long)sc, ctask-&gt;itt);
+	rc = FAILED;
+
+exit:
+	del_timer_sync(&amp;conn-&gt;tmabort_timer);
+
+	down(&amp;conn-&gt;xmitsema);
+	if (conn-&gt;sock) {
+		struct sock *sk = conn-&gt;sock-&gt;sk;
+
+		write_lock_bh(&amp;sk-&gt;sk_callback_lock);
+		iscsi_ctask_cleanup(conn, ctask);
+		write_unlock_bh(&amp;sk-&gt;sk_callback_lock);
+	}
+	up(&amp;conn-&gt;xmitsema);
+	return rc;
+}
+
+static int
+iscsi_r2tpool_alloc(struct iscsi_session *session)
+{
+	int i;
+	int cmd_i;
+
+	/*
+	 * initialize per-task: R2T pool and xmit queue
+	 */
+	for (cmd_i = 0; cmd_i &lt; session-&gt;cmds_max; cmd_i++) {
+	        struct iscsi_cmd_task *ctask = session-&gt;cmds[cmd_i];
+
+		/*
+		 * pre-allocated x4 as much r2ts to handle race when
+		 * target acks DataOut faster than we data_xmit() queues
+		 * could replenish r2tqueue.
+		 */
+
+		/* R2T pool */
+		if (iscsi_pool_init(&amp;ctask-&gt;r2tpool, session-&gt;max_r2t * 4,
+			(void***)&amp;ctask-&gt;r2ts, sizeof(struct iscsi_r2t_info))) {
+			goto r2t_alloc_fail;
+		}
+
+		/* R2T xmit queue */
+		ctask-&gt;r2tqueue = kfifo_alloc(
+		      session-&gt;max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
+		if (ctask-&gt;r2tqueue == ERR_PTR(-ENOMEM)) {
+			iscsi_pool_free(&amp;ctask-&gt;r2tpool, (void**)ctask-&gt;r2ts);
+			goto r2t_alloc_fail;
+		}
+
+		/*
+		 * number of
+		 * Data-Out PDU's within R2T-sequence can be quite big;
+		 * using mempool
+		 */
+		ctask-&gt;datapool = mempool_create(ISCSI_DTASK_DEFAULT_MAX,
+			 mempool_alloc_slab, mempool_free_slab, taskcache);
+		if (ctask-&gt;datapool == NULL) {
+			kfifo_free(ctask-&gt;r2tqueue);
+			iscsi_pool_free(&amp;ctask-&gt;r2tpool, (void**)ctask-&gt;r2ts);
+			goto r2t_alloc_fail;
+		}
+		INIT_LIST_HEAD(&amp;ctask-&gt;dataqueue);
+	}
+
+	return 0;
+
+r2t_alloc_fail:
+	for (i = 0; i &lt; cmd_i; i++) {
+		mempool_destroy(session-&gt;cmds[i]-&gt;datapool);
+		kfifo_free(session-&gt;cmds[i]-&gt;r2tqueue);
+		iscsi_pool_free(&amp;session-&gt;cmds[i]-&gt;r2tpool,
+				(void**)session-&gt;cmds[i]-&gt;r2ts);
+	}
+	return -ENOMEM;
+}
+
+static void
+iscsi_r2tpool_free(struct iscsi_session *session)
+{
+	int i;
+
+	for (i = 0; i &lt; session-&gt;cmds_max; i++) {
+		mempool_destroy(session-&gt;cmds[i]-&gt;datapool);
+		kfifo_free(session-&gt;cmds[i]-&gt;r2tqueue);
+		iscsi_pool_free(&amp;session-&gt;cmds[i]-&gt;r2tpool,
+				(void**)session-&gt;cmds[i]-&gt;r2ts);
+	}
+}
+
+static struct scsi_host_template iscsi_sht = {
+	.name			= "iSCSI Initiator over TCP/IP, v."
+				  ISCSI_VERSION_STR,
+        .queuecommand           = iscsi_queuecommand,
+	.can_queue		= ISCSI_XMIT_CMDS_MAX - 1,
+	.sg_tablesize		= ISCSI_SG_TABLESIZE,
+	.cmd_per_lun		= ISCSI_CMD_PER_LUN,
+        .eh_abort_handler       = iscsi_eh_abort,
+        .eh_host_reset_handler	= iscsi_eh_host_reset,
+        .use_clustering         = DISABLE_CLUSTERING,
+	.proc_name		= "iscsi_tcp",
+	.this_id		= -1,
+};
+
+static iscsi_sessionh_t
+iscsi_session_create(uint32_t initial_cmdsn, struct Scsi_Host *host)
+{
+	int cmd_i;
+	struct iscsi_session *session;
+
+	session = iscsi_hostdata(host-&gt;hostdata);
+	memset(session, 0, sizeof(struct iscsi_session));
+
+	session-&gt;host = host;
+	session-&gt;id = host-&gt;host_no;
+	session-&gt;state = ISCSI_STATE_LOGGED_IN;
+	session-&gt;mgmtpool_max = ISCSI_MGMT_CMDS_MAX;
+	session-&gt;cmds_max = ISCSI_XMIT_CMDS_MAX;
+	session-&gt;cmdsn = initial_cmdsn;
+	session-&gt;exp_cmdsn = initial_cmdsn + 1;
+	session-&gt;max_cmdsn = initial_cmdsn + 1;
+	session-&gt;max_r2t = 1;
+
+	/* initialize SCSI PDU commands pool */
+	if (iscsi_pool_init(&amp;session-&gt;cmdpool, session-&gt;cmds_max,
+		(void***)&amp;session-&gt;cmds, sizeof(struct iscsi_cmd_task)))
+		goto cmdpool_alloc_fail;
+
+	/* pre-format cmds pool with ITT */
+	for (cmd_i = 0; cmd_i &lt; session-&gt;cmds_max; cmd_i++)
+		session-&gt;cmds[cmd_i]-&gt;itt = cmd_i;
+
+	spin_lock_init(&amp;session-&gt;lock);
+	INIT_LIST_HEAD(&amp;session-&gt;connections);
+
+	/* initialize immediate command pool */
+	if (iscsi_pool_init(&amp;session-&gt;mgmtpool, session-&gt;mgmtpool_max,
+		(void***)&amp;session-&gt;mgmt_cmds, sizeof(struct iscsi_mgmt_task)))
+		goto mgmtpool_alloc_fail;
+
+
+	/* pre-format immediate cmds pool with ITT */
+	for (cmd_i = 0; cmd_i &lt; session-&gt;mgmtpool_max; cmd_i++) {
+		session-&gt;mgmt_cmds[cmd_i]-&gt;itt = ISCSI_MGMT_ITT_OFFSET + cmd_i;
+		session-&gt;mgmt_cmds[cmd_i]-&gt;data = kmalloc(
+			DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH, GFP_KERNEL);
+		if (!session-&gt;mgmt_cmds[cmd_i]-&gt;data) {
+			int j;
+
+			for (j = 0; j &lt; cmd_i; j++)
+				kfree(session-&gt;mgmt_cmds[j]-&gt;data);
+			goto immdata_alloc_fail;
+		}
+	}
+
+	if (iscsi_r2tpool_alloc(session))
+		goto r2tpool_alloc_fail;
+
+	return iscsi_handle(session);
+
+r2tpool_alloc_fail:
+	for (cmd_i = 0; cmd_i &lt; session-&gt;mgmtpool_max; cmd_i++)
+		kfree(session-&gt;mgmt_cmds[cmd_i]-&gt;data);
+	iscsi_pool_free(&amp;session-&gt;mgmtpool, (void**)session-&gt;mgmt_cmds);
+immdata_alloc_fail:
+mgmtpool_alloc_fail:
+	iscsi_pool_free(&amp;session-&gt;cmdpool, (void**)session-&gt;cmds);
+cmdpool_alloc_fail:
+	return iscsi_handle(NULL);
+}
+
+static void
+iscsi_session_destroy(iscsi_sessionh_t sessionh)
+{
+	int cmd_i;
+	struct iscsi_data_task *dtask, *n;
+	struct iscsi_session *session = iscsi_ptr(sessionh);
+
+	for (cmd_i = 0; cmd_i &lt; session-&gt;cmds_max; cmd_i++) {
+		struct iscsi_cmd_task *ctask = session-&gt;cmds[cmd_i];
+		list_for_each_entry_safe(dtask, n, &amp;ctask-&gt;dataqueue, item) {
+			list_del(&amp;dtask-&gt;item);
+			mempool_free(dtask, ctask-&gt;datapool);
+		}
+	}
+
+	for (cmd_i = 0; cmd_i &lt; session-&gt;mgmtpool_max; cmd_i++)
+		kfree(session-&gt;mgmt_cmds[cmd_i]-&gt;data);
+
+	iscsi_r2tpool_free(session);
+	iscsi_pool_free(&amp;session-&gt;mgmtpool, (void**)session-&gt;mgmt_cmds);
+	iscsi_pool_free(&amp;session-&gt;cmdpool, (void**)session-&gt;cmds);
+}
+
+static int
+iscsi_conn_set_param(iscsi_connh_t connh, enum iscsi_param param,
+		     uint32_t value)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	struct iscsi_session *session = conn-&gt;session;
+
+	spin_lock_bh(&amp;session-&gt;lock);
+	if (conn-&gt;c_stage != ISCSI_CONN_INITIAL_STAGE &amp;&amp;
+	    conn-&gt;stop_stage != STOP_CONN_RECOVER) {
+		printk(KERN_ERR "iscsi_tcp: can not change parameter [%d]\n",
+		       param);
+		spin_unlock_bh(&amp;session-&gt;lock);
+		return 0;
+	}
+	spin_unlock_bh(&amp;session-&gt;lock);
+
+	switch(param) {
+	case ISCSI_PARAM_MAX_RECV_DLENGTH: {
+		char *saveptr = conn-&gt;data;
+		int flags = GFP_KERNEL;
+
+		if (conn-&gt;data_size &gt;= value) {
+			conn-&gt;max_recv_dlength = value;
+			break;
+		}
+
+		spin_lock_bh(&amp;session-&gt;lock);
+		if (conn-&gt;stop_stage == STOP_CONN_RECOVER)
+			flags = GFP_ATOMIC;
+		spin_unlock_bh(&amp;session-&gt;lock);
+
+		if (value &lt;= PAGE_SIZE)
+			conn-&gt;data = kmalloc(value, flags);
+		else
+			conn-&gt;data = (void*)__get_free_pages(flags,
+							     get_order(value));
+		if (conn-&gt;data == NULL) {
+			conn-&gt;data = saveptr;
+			return -ENOMEM;
+		}
+		if (conn-&gt;data_size &lt;= PAGE_SIZE)
+			kfree(saveptr);
+		else
+			free_pages((unsigned long)saveptr,
+				   get_order(conn-&gt;data_size));
+		conn-&gt;max_recv_dlength = value;
+		conn-&gt;data_size = value;
+		}
+		break;
+	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
+		conn-&gt;max_xmit_dlength =  value;
+		break;
+	case ISCSI_PARAM_HDRDGST_EN:
+		conn-&gt;hdrdgst_en = value;
+		conn-&gt;hdr_size = sizeof(struct iscsi_hdr);
+		if (conn-&gt;hdrdgst_en) {
+			conn-&gt;hdr_size += sizeof(__u32);
+			if (!conn-&gt;tx_tfm)
+				conn-&gt;tx_tfm = crypto_alloc_tfm("crc32c", 0);
+			if (!conn-&gt;tx_tfm)
+				return -ENOMEM;
+			if (!conn-&gt;rx_tfm)
+				conn-&gt;rx_tfm = crypto_alloc_tfm("crc32c", 0);
+			if (!conn-&gt;rx_tfm) {
+				crypto_free_tfm(conn-&gt;tx_tfm);
+				return -ENOMEM;
+			}
+		} else {
+			if (conn-&gt;tx_tfm)
+				crypto_free_tfm(conn-&gt;tx_tfm);
+			if (conn-&gt;rx_tfm)
+				crypto_free_tfm(conn-&gt;rx_tfm);
+		}
+		break;
+	case ISCSI_PARAM_DATADGST_EN:
+		conn-&gt;datadgst_en = value;
+		if (conn-&gt;datadgst_en) {
+			if (!conn-&gt;data_tx_tfm)
+				conn-&gt;data_tx_tfm =
+				    crypto_alloc_tfm("crc32c", 0);
+			if (!conn-&gt;data_tx_tfm)
+				return -ENOMEM;
+			if (!conn-&gt;data_rx_tfm)
+				conn-&gt;data_rx_tfm =
+				    crypto_alloc_tfm("crc32c", 0);
+			if (!conn-&gt;data_rx_tfm) {
+				crypto_free_tfm(conn-&gt;data_tx_tfm);
+				return -ENOMEM;
+			}
+		} else {
+			if (conn-&gt;data_tx_tfm)
+				crypto_free_tfm(conn-&gt;data_tx_tfm);
+			if (conn-&gt;data_rx_tfm)
+				crypto_free_tfm(conn-&gt;data_rx_tfm);
+		}
+		break;
+	case ISCSI_PARAM_INITIAL_R2T_EN:
+		session-&gt;initial_r2t_en = value;
+		break;
+	case ISCSI_PARAM_MAX_R2T:
+		if (session-&gt;max_r2t == roundup_pow_of_two(value))
+			break;
+		iscsi_r2tpool_free(session);
+		session-&gt;max_r2t = value;
+		if (session-&gt;max_r2t &amp; (session-&gt;max_r2t - 1))
+			session-&gt;max_r2t = roundup_pow_of_two(session-&gt;max_r2t);
+		if (iscsi_r2tpool_alloc(session))
+			return -ENOMEM;
+		break;
+	case ISCSI_PARAM_IMM_DATA_EN:
+		session-&gt;imm_data_en = value;
+		break;
+	case ISCSI_PARAM_FIRST_BURST:
+		session-&gt;first_burst = value;
+		break;
+	case ISCSI_PARAM_MAX_BURST:
+		session-&gt;max_burst = value;
+		break;
+	case ISCSI_PARAM_PDU_INORDER_EN:
+		session-&gt;pdu_inorder_en = value;
+		break;
+	case ISCSI_PARAM_DATASEQ_INORDER_EN:
+		session-&gt;dataseq_inorder_en = value;
+		break;
+	case ISCSI_PARAM_ERL:
+		session-&gt;erl = value;
+		break;
+	case ISCSI_PARAM_IFMARKER_EN:
+		BUG_ON(value);
+		session-&gt;ifmarker_en = value;
+		break;
+	case ISCSI_PARAM_OFMARKER_EN:
+		BUG_ON(value);
+		session-&gt;ofmarker_en = value;
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int
+iscsi_conn_get_param(iscsi_connh_t connh, enum iscsi_param param,
+		     uint32_t *value)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	struct iscsi_session *session = conn-&gt;session;
+
+	switch(param) {
+	case ISCSI_PARAM_MAX_RECV_DLENGTH:
+		*value = conn-&gt;max_recv_dlength;
+		break;
+	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
+		*value = conn-&gt;max_xmit_dlength;
+		break;
+	case ISCSI_PARAM_HDRDGST_EN:
+		*value = conn-&gt;hdrdgst_en;
+		break;
+	case ISCSI_PARAM_DATADGST_EN:
+		*value = conn-&gt;datadgst_en;
+		break;
+	case ISCSI_PARAM_INITIAL_R2T_EN:
+		*value = session-&gt;initial_r2t_en;
+		break;
+	case ISCSI_PARAM_MAX_R2T:
+		*value = session-&gt;max_r2t;
+		break;
+	case ISCSI_PARAM_IMM_DATA_EN:
+		*value = session-&gt;imm_data_en;
+		break;
+	case ISCSI_PARAM_FIRST_BURST:
+		*value = session-&gt;first_burst;
+		break;
+	case ISCSI_PARAM_MAX_BURST:
+		*value = session-&gt;max_burst;
+		break;
+	case ISCSI_PARAM_PDU_INORDER_EN:
+		*value = session-&gt;pdu_inorder_en;
+		break;
+	case ISCSI_PARAM_DATASEQ_INORDER_EN:
+		*value = session-&gt;dataseq_inorder_en;
+		break;
+	case ISCSI_PARAM_ERL:
+		*value = session-&gt;erl;
+		break;
+	case ISCSI_PARAM_IFMARKER_EN:
+		*value = session-&gt;ifmarker_en;
+		break;
+	case ISCSI_PARAM_OFMARKER_EN:
+		*value = session-&gt;ofmarker_en;
+		break;
+	default:
+		return ISCSI_ERR_PARAM_NOT_FOUND;
+	}
+
+	return 0;
+}
+
+static void
+iscsi_conn_get_stats(iscsi_connh_t connh, struct iscsi_stats *stats)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+
+	stats-&gt;txdata_octets = conn-&gt;txdata_octets;
+	stats-&gt;rxdata_octets = conn-&gt;rxdata_octets;
+	stats-&gt;scsicmd_pdus = conn-&gt;scsicmd_pdus_cnt;
+	stats-&gt;dataout_pdus = conn-&gt;dataout_pdus_cnt;
+	stats-&gt;scsirsp_pdus = conn-&gt;scsirsp_pdus_cnt;
+	stats-&gt;datain_pdus = conn-&gt;datain_pdus_cnt;
+	stats-&gt;r2t_pdus = conn-&gt;r2t_pdus_cnt;
+	stats-&gt;tmfcmd_pdus = conn-&gt;tmfcmd_pdus_cnt;
+	stats-&gt;tmfrsp_pdus = conn-&gt;tmfrsp_pdus_cnt;
+	stats-&gt;custom_length = 3;
+	strcpy(stats-&gt;custom[0].desc, "tx_sendpage_failures");
+	stats-&gt;custom[0].value = conn-&gt;sendpage_failures_cnt;
+	strcpy(stats-&gt;custom[1].desc, "rx_discontiguous_hdr");
+	stats-&gt;custom[1].value = conn-&gt;discontiguous_hdr_cnt;
+	strcpy(stats-&gt;custom[2].desc, "eh_abort_cnt");
+	stats-&gt;custom[2].value = conn-&gt;eh_abort_cnt;
+}
+
+static int
+iscsi_conn_send_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr, char *data,
+		    uint32_t data_size)
+{
+	struct iscsi_conn *conn = iscsi_ptr(connh);
+	int rc;
+
+	down(&amp;conn-&gt;xmitsema);
+	rc = iscsi_conn_send_generic(conn, hdr, data, data_size);
+	up(&amp;conn-&gt;xmitsema);
+
+	return rc;
+}
+
+static struct iscsi_transport iscsi_tcp_transport = {
+	.owner			= THIS_MODULE,
+	.name			= "tcp",
+	.caps			= CAP_RECOVERY_L0 | CAP_MULTI_R2T | CAP_HDRDGST
+				  | CAP_DATADGST,
+	.host_template		= &amp;iscsi_sht,
+	.hostdata_size		= sizeof(struct iscsi_session),
+	.max_conn		= 1,
+	.max_cmd_len		= ISCSI_TCP_MAX_CMD_LEN,
+	.create_session		= iscsi_session_create,
+	.destroy_session	= iscsi_session_destroy,
+	.create_conn		= iscsi_conn_create,
+	.bind_conn		= iscsi_conn_bind,
+	.destroy_conn		= iscsi_conn_destroy,
+	.set_param		= iscsi_conn_set_param,
+	.get_param		= iscsi_conn_get_param,
+	.start_conn		= iscsi_conn_start,
+	.stop_conn		= iscsi_conn_stop,
+	.send_pdu		= iscsi_conn_send_pdu,
+	.get_stats		= iscsi_conn_get_stats,
+};
+
+static int __init
+iscsi_tcp_init(void)
+{
+	int error;
+
+	if (iscsi_max_lun &lt; 1) {
+		printk(KERN_ERR "Invalid max_lun value of %u\n", iscsi_max_lun);
+		return -EINVAL;
+	}
+	iscsi_tcp_transport.max_lun = iscsi_max_lun;
+
+	taskcache = kmem_cache_create("iscsi_taskcache",
+			sizeof(struct iscsi_data_task), 0,
+			SLAB_HWCACHE_ALIGN | SLAB_NO_REAP, NULL, NULL);
+	if (!taskcache)
+		return -ENOMEM;
+
+	error = iscsi_register_transport(&amp;iscsi_tcp_transport);
+	if (error)
+		kmem_cache_destroy(taskcache);
+
+	return error;
+}
+
+static void __exit
+iscsi_tcp_exit(void)
+{
+	iscsi_unregister_transport(&amp;iscsi_tcp_transport);
+	kmem_cache_destroy(taskcache);
+}
+
+module_init(iscsi_tcp_init);
+module_exit(iscsi_tcp_exit);
diff --git a/drivers/scsi/iscsi_tcp.h b/drivers/scsi/iscsi_tcp.h
new file mode 100644
--- /dev/null
+++ b/drivers/scsi/iscsi_tcp.h
@@ -0,0 +1,322 @@
+/*
+ * iSCSI Initiator TCP Transport
+ * Copyright (C) 2004 Dmitry Yusupov
+ * Copyright (C) 2004 Alex Aizman
+ * Copyright (C) 2005 Mike Christie
+ * maintained by open-iscsi@googlegroups.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * See the file COPYING included with this distribution for more details.
+ */
+
+#ifndef ISCSI_TCP_H
+#define ISCSI_TCP_H
+
+/* Session's states */
+#define ISCSI_STATE_FREE		1
+#define ISCSI_STATE_LOGGED_IN		2
+#define ISCSI_STATE_FAILED		3
+#define ISCSI_STATE_TERMINATE		4
+
+/* Connection's states */
+#define ISCSI_CONN_INITIAL_STAGE	0
+#define ISCSI_CONN_STARTED		1
+#define ISCSI_CONN_STOPPED		2
+#define ISCSI_CONN_CLEANUP_WAIT		3
+
+/* Connection suspend "bit" */
+#define SUSPEND_BIT			1
+
+/* Socket's Receive state machine */
+#define IN_PROGRESS_WAIT_HEADER		0x0
+#define IN_PROGRESS_HEADER_GATHER	0x1
+#define IN_PROGRESS_DATA_RECV		0x2
+#define IN_PROGRESS_DDIGEST_RECV	0x3
+
+/* Task Mgmt states */
+#define	TMABORT_INITIAL			0x0
+#define	TMABORT_SUCCESS			0x1
+#define	TMABORT_FAILED			0x2
+#define	TMABORT_TIMEDOUT		0x3
+
+/* xmit state machine */
+#define	XMSTATE_IDLE			0x0
+#define	XMSTATE_R_HDR			0x1
+#define	XMSTATE_W_HDR			0x2
+#define	XMSTATE_IMM_HDR			0x4
+#define	XMSTATE_IMM_DATA		0x8
+#define	XMSTATE_UNS_INIT		0x10
+#define	XMSTATE_UNS_HDR			0x20
+#define	XMSTATE_UNS_DATA		0x40
+#define	XMSTATE_SOL_HDR			0x80
+#define	XMSTATE_SOL_DATA		0x100
+#define	XMSTATE_W_PAD			0x200
+#define XMSTATE_DATA_DIGEST		0x400
+
+#define ISCSI_CONN_MAX			1
+#define ISCSI_CONN_RCVBUF_MIN		262144
+#define ISCSI_CONN_SNDBUF_MIN		262144
+#define ISCSI_PAD_LEN			4
+#define ISCSI_R2T_MAX			16
+#define ISCSI_XMIT_CMDS_MAX		128	/* must be power of 2 */
+#define ISCSI_MGMT_CMDS_MAX		32	/* must be power of 2 */
+#define ISCSI_MGMT_ITT_OFFSET		0xa00
+#define ISCSI_SG_TABLESIZE		SG_ALL
+#define ISCSI_CMD_PER_LUN		128
+#define ISCSI_TCP_MAX_CMD_LEN		16
+
+#define ITT_MASK			(0xfff)
+#define CID_SHIFT			12
+#define CID_MASK			(0xffff&lt;&lt;CID_SHIFT)
+#define AGE_SHIFT			28
+#define AGE_MASK			(0xf&lt;&lt;AGE_SHIFT)
+
+struct iscsi_queue {
+	struct kfifo		*queue;		/* FIFO Queue */
+	void			**pool;		/* Pool of elements */
+	int			max;		/* Max number of elements */
+};
+
+struct iscsi_session;
+struct iscsi_cmd_task;
+struct iscsi_mgmt_task;
+
+/* Socket connection recieve helper */
+struct iscsi_tcp_recv {
+	struct iscsi_hdr	*hdr;
+	struct sk_buff		*skb;
+	int			offset;
+	int			len;
+	int			hdr_offset;
+	int			copy;
+	int			copied;
+	int			padding;
+	struct iscsi_cmd_task	*ctask;		/* current cmd in progress */
+
+	/* copied and flipped values */
+	int			opcode;
+	int			flags;
+	int			cmd_status;
+	int			ahslen;
+	int			datalen;
+	uint32_t		itt;
+	int			datadgst;
+};
+
+struct iscsi_conn {
+	struct iscsi_hdr	hdr;		/* header placeholder */
+	char			hdrext[4*sizeof(__u16) +
+				    sizeof(__u32)];
+	int			data_copied;
+	char			*data;		/* data placeholder */
+	struct socket           *sock;          /* TCP socket */
+	int			data_size;	/* actual recv_dlength */
+	int			stop_stage;	/* conn_stop() flag: *
+						 * stop to recover,  *
+						 * stop to terminate */
+	/* iSCSI connection-wide sequencing */
+	uint32_t		exp_statsn;
+	int			hdr_size;	/* PDU header size */
+	unsigned long		suspend_rx;	/* suspend Rx */
+
+	struct crypto_tfm	*rx_tfm;	/* CRC32C (Rx) */
+	struct crypto_tfm	*data_rx_tfm;	/* CRC32C (Rx) for data */
+
+	/* control data */
+	int			senselen;	/* scsi sense length */
+	int			id;		/* CID */
+	struct iscsi_tcp_recv	in;		/* TCP receive context */
+	struct iscsi_session	*session;	/* parent session */
+	struct list_head	item;		/* maintains list of conns */
+	int			in_progress;	/* connection state machine */
+	int			c_stage;	/* connection state */
+	struct iscsi_mgmt_task	*login_mtask;	/* mtask used for login/text */
+	struct iscsi_mgmt_task	*mtask;		/* xmit mtask in progress */
+	struct iscsi_cmd_task	*ctask;		/* xmit ctask in progress */
+	spinlock_t		lock;		/* FIXME: to be removed */
+
+	/* old values for socket callbacks */
+	void			(*old_data_ready)(struct sock *, int);
+	void			(*old_state_change)(struct sock *);
+	void			(*old_write_space)(struct sock *);
+
+	/* xmit */
+	struct crypto_tfm	*tx_tfm;	/* CRC32C (Tx) */
+	struct crypto_tfm	*data_tx_tfm;	/* CRC32C (Tx) for data */
+	struct kfifo		*writequeue;	/* write cmds for Data-Outs */
+	struct kfifo		*immqueue;	/* immediate xmit queue */
+	struct kfifo		*mgmtqueue;	/* mgmt (control) xmit queue */
+	struct kfifo		*xmitqueue;	/* data-path cmd queue */
+	struct work_struct	xmitwork;	/* per-conn. xmit workqueue */
+	struct semaphore	xmitsema;	/* serializes connection xmit,
+						 * access to kfifos:	  *
+						 * xmitqueue, writequeue, *
+						 * immqueue, mgmtqueue    */
+	unsigned long		suspend_tx;	/* suspend Tx */
+
+	/* abort */
+	wait_queue_head_t	ehwait;		/* used in eh_abort()     */
+	struct iscsi_tm		tmhdr;
+	struct timer_list	tmabort_timer;  /* abort timer */
+	int			tmabort_state;  /* see TMABORT_INITIAL, etc.*/
+
+	/* negotiated params */
+	int			max_recv_dlength;
+	int			max_xmit_dlength;
+	int			hdrdgst_en;
+	int			datadgst_en;
+
+	/* MIB-statistics */
+	uint64_t		txdata_octets;
+	uint64_t		rxdata_octets;
+	uint32_t		scsicmd_pdus_cnt;
+	uint32_t		dataout_pdus_cnt;
+	uint32_t		scsirsp_pdus_cnt;
+	uint32_t		datain_pdus_cnt;
+	uint32_t		r2t_pdus_cnt;
+	uint32_t		tmfcmd_pdus_cnt;
+	int32_t			tmfrsp_pdus_cnt;
+
+	/* custom statistics */
+	uint32_t		sendpage_failures_cnt;
+	uint32_t		discontiguous_hdr_cnt;
+	uint32_t		eh_abort_cnt;
+};
+
+struct iscsi_session {
+	/* iSCSI session-wide sequencing */
+	uint32_t		cmdsn;
+	uint32_t		exp_cmdsn;
+	uint32_t		max_cmdsn;
+
+	/* configuration */
+	int			initial_r2t_en;
+	int			max_r2t;
+	int			imm_data_en;
+	int			first_burst;
+	int			max_burst;
+	int			time2wait;
+	int			time2retain;
+	int			pdu_inorder_en;
+	int			dataseq_inorder_en;
+	int			erl;
+	int			ifmarker_en;
+	int			ofmarker_en;
+
+	/* control data */
+	struct Scsi_Host	*host;
+	int			id;
+	struct iscsi_conn	*leadconn;	/* leading connection */
+	spinlock_t		lock;		/* protects session state, *
+						 * sequence numbers,       *
+						 * session resources:      *
+						 * - cmdpool,		   *
+						 * - mgmtpool,		   *
+						 * - r2tpool		   */
+	int			state;		/* session state           */
+	struct list_head	item;
+	void			*auth_client;
+	int			conn_cnt;
+	int			age;		/* counts session re-opens */
+
+	struct list_head	connections;	/* list of connections */
+	int			cmds_max;	/* size of cmds array */
+	struct iscsi_cmd_task	**cmds;		/* Original Cmds arr */
+	struct iscsi_queue	cmdpool;	/* PDU's pool */
+	int			mgmtpool_max;	/* size of mgmt array */
+	struct iscsi_mgmt_task	**mgmt_cmds;	/* Original mgmt arr */
+	struct iscsi_queue	mgmtpool;	/* Mgmt PDU's pool */
+};
+
+struct iscsi_buf {
+	struct scatterlist	sg;
+	struct kvec		iov;
+	unsigned int		sent;
+};
+
+struct iscsi_data_task {
+	struct iscsi_data	hdr;			/* PDU */
+	char			hdrext[sizeof(__u32)];	/* Header-Digest */
+	struct list_head	item;			/* data queue item */
+	struct iscsi_buf	digestbuf;		/* digest buffer */
+	uint32_t		digest;			/* data digest */
+};
+#define ISCSI_DTASK_DEFAULT_MAX	ISCSI_SG_TABLESIZE * PAGE_SIZE / 512
+
+struct iscsi_mgmt_task {
+	struct iscsi_hdr	hdr;		/* mgmt. PDU */
+	char			hdrext[sizeof(__u32)];	/* Header-Digest */
+	char			*data;		/* mgmt payload */
+	int			xmstate;	/* mgmt xmit progress */
+	int			data_count;	/* counts data to be sent */
+	struct iscsi_buf	headbuf;	/* header buffer */
+	struct iscsi_buf	sendbuf;	/* in progress buffer */
+	int			sent;
+	uint32_t		itt;		/* this ITT */
+};
+
+struct iscsi_r2t_info {
+	__be32			ttt;		/* copied from R2T */
+	__be32			exp_statsn;	/* copied from R2T */
+	uint32_t		data_length;	/* copied from R2T */
+	uint32_t		data_offset;	/* copied from R2T */
+	struct iscsi_buf	headbuf;	/* Data-Out Header Buffer */
+	struct iscsi_buf	sendbuf;	/* Data-Out in progress buffer*/
+	int			sent;		/* R2T sequence progress */
+	int			data_count;	/* DATA-Out payload progress */
+	struct scatterlist	*sg;		/* per-R2T SG list */
+	int			solicit_datasn;
+	struct iscsi_data_task   *dtask;        /* which data task */
+};
+
+struct iscsi_cmd_task {
+	struct iscsi_cmd	hdr;			/* iSCSI PDU header */
+	char			hdrext[4*sizeof(__u16)+	/* AHS */
+				    sizeof(__u32)];	/* HeaderDigest */
+	char			pad[ISCSI_PAD_LEN];
+	int			itt;			/* this ITT */
+	int			datasn;			/* DataSN */
+	struct iscsi_buf	headbuf;		/* header buf (xmit) */
+	struct iscsi_buf	sendbuf;		/* in progress buffer*/
+	int			sent;
+	struct scatterlist	*sg;			/* per-cmd SG list  */
+	struct scatterlist	*bad_sg;		/* assert statement */
+	int			sg_count;		/* SG's to process  */
+	uint32_t		unsol_datasn;
+	uint32_t		exp_r2tsn;
+	int			xmstate;		/* xmit xtate machine */
+	int			imm_count;		/* imm-data (bytes)   */
+	int			unsol_count;		/* unsolicited (bytes)*/
+	int			r2t_data_count;		/* R2T Data-Out bytes */
+	int			data_count;		/* remaining Data-Out */
+	int			pad_count;		/* padded bytes */
+	struct scsi_cmnd	*sc;			/* associated SCSI cmd*/
+	int			total_length;
+	int			data_offset;
+	struct iscsi_conn	*conn;			/* used connection    */
+	struct iscsi_mgmt_task	*mtask;			/* tmf mtask in progr */
+
+	struct iscsi_r2t_info	*r2t;			/* in progress R2T    */
+	struct iscsi_queue	r2tpool;
+	struct kfifo		*r2tqueue;
+	struct iscsi_r2t_info	**r2ts;
+	struct list_head	dataqueue;		/* Data-Out dataqueue */
+	mempool_t		*datapool;
+	uint32_t		datadigest;		/* for recover digest */
+	int			digest_count;
+	uint32_t		immdigest;		/* for imm data */
+	struct iscsi_buf	immbuf;			/* for imm data digest */
+	struct iscsi_data_task   *dtask;		/* data task in progress*/
+	int			digest_offset;		/* for partial buff digest */
+};
+
+#endif /* ISCSI_H */
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -1,8 +1,10 @@
-/* 
+/*
  * iSCSI transport class definitions
  *
  * Copyright (C) IBM Corporation, 2004
- * Copyright (C) Mike Christie, 2004
+ * Copyright (C) Mike Christie, 2004 - 2005
+ * Copyright (C) Dmitry Yusupov, 2004 - 2005
+ * Copyright (C) Alex Aizman, 2004 - 2005
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,370 +21,1253 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 #include &lt;linux/module.h&gt;
+#include &lt;linux/mempool.h&gt;
+#include &lt;net/tcp.h&gt;
 #include &lt;scsi/scsi.h&gt;
 #include &lt;scsi/scsi_host.h&gt;
 #include &lt;scsi/scsi_device.h&gt;
 #include &lt;scsi/scsi_transport.h&gt;
 #include &lt;scsi/scsi_transport_iscsi.h&gt;
+#include &lt;scsi/iscsi_if.h&gt;
 
-#define ISCSI_SESSION_ATTRS 20
-#define ISCSI_HOST_ATTRS 2
+#define ISCSI_SESSION_ATTRS 8
+#define ISCSI_CONN_ATTRS 6
 
 struct iscsi_internal {
 	struct scsi_transport_template t;
-	struct iscsi_function_template *fnt;
+	struct iscsi_transport *iscsi_transport;
+	struct list_head list;
+	/*
+	 * List of sessions for this transport
+	 */
+	struct list_head sessions;
+	/*
+	 * lock to serialize access to the sessions list which must
+	 * be taken after the rx_queue_sema
+	 */
+	spinlock_t session_lock;
+	/*
+	 * based on transport capabilities, at register time we set these
+	 * bits to tell the transport class it wants attributes displayed
+	 * in sysfs or that it can support different iSCSI Data-Path
+	 * capabilities
+	 */
+	uint32_t param_mask;
+
+	struct class_device cdev;
 	/*
 	 * We do not have any private or other attrs.
 	 */
+	struct transport_container conn_cont;
+	struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
+	struct transport_container session_cont;
 	struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
-	struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
 };
 
-#define to_iscsi_internal(tmpl) container_of(tmpl, struct iscsi_internal, t)
+/*
+ * list of registered transports and lock that must
+ * be held while accessing list. The iscsi_transport_lock must
+ * be acquired after the rx_queue_sema.
+ */
+static LIST_HEAD(iscsi_transports);
+static DEFINE_SPINLOCK(iscsi_transport_lock);
+
+#define to_iscsi_internal(tmpl) \
+	container_of(tmpl, struct iscsi_internal, t)
+
+#define cdev_to_iscsi_internal(_cdev) \
+	container_of(_cdev, struct iscsi_internal, cdev)
+
+static void iscsi_transport_release(struct class_device *cdev)
+{
+	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
+	kfree(priv);
+}
+
+/*
+ * iscsi_transport_class represents the iscsi_transports that are
+ * registered.
+ */
+static struct class iscsi_transport_class = {
+	.name = "iscsi_transport",
+	.release = iscsi_transport_release,
+};
+
+static ssize_t
+show_transport_handle(struct class_device *cdev, char *buf)
+{
+	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
+	return sprintf(buf, "%llu", (unsigned long long)iscsi_handle(priv-&gt;iscsi_transport));
+}
+static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
+
+#define show_transport_attr(name, format)				\
+static ssize_t								\
+show_transport_##name(struct class_device *cdev, char *buf)		\
+{									\
+	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);	\
+	return sprintf(buf, format"\n", priv-&gt;iscsi_transport-&gt;name);	\
+}									\
+static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
+
+show_transport_attr(caps, "0x%x");
+show_transport_attr(max_lun, "%d");
+show_transport_attr(max_conn, "%d");
+show_transport_attr(max_cmd_len, "%d");
+
+static struct attribute *iscsi_transport_attrs[] = {
+	&amp;class_device_attr_handle.attr,
+	&amp;class_device_attr_caps.attr,
+	&amp;class_device_attr_max_lun.attr,
+	&amp;class_device_attr_max_conn.attr,
+	&amp;class_device_attr_max_cmd_len.attr,
+	NULL,
+};
 
-static DECLARE_TRANSPORT_CLASS(iscsi_transport_class,
-			       "iscsi_transport",
+static struct attribute_group iscsi_transport_group = {
+	.attrs = iscsi_transport_attrs,
+};
+
+static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
+			       "iscsi_session",
 			       NULL,
 			       NULL,
 			       NULL);
 
-static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
-			       "iscsi_host",
+static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
+			       "iscsi_connection",
 			       NULL,
 			       NULL,
 			       NULL);
+
+static struct sock *nls;
+static int daemon_pid;
+static DECLARE_MUTEX(rx_queue_sema);
+
+struct mempool_zone {
+	mempool_t *pool;
+	atomic_t allocated;
+	int size;
+	int hiwat;
+	struct list_head freequeue;
+	spinlock_t freelock;
+};
+
+static struct mempool_zone z_reply;
+
 /*
- * iSCSI target and session attrs
+ * Z_MAX_* - actual mempool size allocated at the mempool_zone_init() time
+ * Z_HIWAT_* - zone's high watermark when if_error bit will be set to -ENOMEM
+ *             so daemon will notice OOM on NETLINK tranposrt level and will
+ *             be able to predict or change operational behavior
  */
-#define iscsi_session_show_fn(field, format)				\
-									\
-static ssize_t								\
-show_session_##field(struct class_device *cdev, char *buf)		\
-{									\
-	struct scsi_target *starget = transport_class_to_starget(cdev);	\
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);	\
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt); \
-									\
-	if (i-&gt;fnt-&gt;get_##field)					\
-		i-&gt;fnt-&gt;get_##field(starget);				\
-	return snprintf(buf, 20, format"\n", iscsi_##field(starget));	\
-}
-
-#define iscsi_session_rd_attr(field, format)				\
-	iscsi_session_show_fn(field, format)				\
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_##field, NULL);
-
-iscsi_session_rd_attr(tpgt, "%hu");
-iscsi_session_rd_attr(tsih, "%2x");
-iscsi_session_rd_attr(max_recv_data_segment_len, "%u");
-iscsi_session_rd_attr(max_burst_len, "%u");
-iscsi_session_rd_attr(first_burst_len, "%u");
-iscsi_session_rd_attr(def_time2wait, "%hu");
-iscsi_session_rd_attr(def_time2retain, "%hu");
-iscsi_session_rd_attr(max_outstanding_r2t, "%hu");
-iscsi_session_rd_attr(erl, "%d");
+#define Z_MAX_REPLY	8
+#define Z_HIWAT_REPLY	6
+#define Z_MAX_PDU	8
+#define Z_HIWAT_PDU	6
+#define Z_MAX_ERROR	16
+#define Z_HIWAT_ERROR	12
+
+struct iscsi_if_conn {
+	struct list_head conn_list;	/* item in connlist */
+	struct list_head session_list;	/* item in session-&gt;connections */
+	iscsi_connh_t connh;
+	int active;			/* must be accessed with the connlock */
+	struct Scsi_Host *host;		/* originated shost */
+	struct device dev;		/* sysfs transport/container device */
+	struct iscsi_transport *transport;
+	struct mempool_zone z_error;
+	struct mempool_zone z_pdu;
+	struct list_head freequeue;
+};
 
+#define iscsi_dev_to_if_conn(_dev) \
+	container_of(_dev, struct iscsi_if_conn, dev)
 
-#define iscsi_session_show_bool_fn(field)				\
-									\
-static ssize_t								\
-show_session_bool_##field(struct class_device *cdev, char *buf)		\
-{									\
-	struct scsi_target *starget = transport_class_to_starget(cdev);	\
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);	\
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt); \
-									\
-	if (i-&gt;fnt-&gt;get_##field)					\
-		i-&gt;fnt-&gt;get_##field(starget);				\
-									\
-	if (iscsi_##field(starget))					\
-		return sprintf(buf, "Yes\n");				\
-	return sprintf(buf, "No\n");					\
+#define iscsi_cdev_to_if_conn(_cdev) \
+	iscsi_dev_to_if_conn(_cdev-&gt;dev)
+
+static LIST_HEAD(connlist);
+static DEFINE_SPINLOCK(connlock);
+
+struct iscsi_if_session {
+	struct list_head list;	/* item in session_list */
+	struct list_head connections;
+	iscsi_sessionh_t sessionh;
+	struct iscsi_transport *transport;
+	struct device dev;	/* sysfs transport/container device */
+};
+
+#define iscsi_dev_to_if_session(_dev) \
+	container_of(_dev, struct iscsi_if_session, dev)
+
+#define iscsi_cdev_to_if_session(_cdev) \
+	iscsi_dev_to_if_session(_cdev-&gt;dev)
+
+#define iscsi_if_session_to_shost(_session) \
+	dev_to_shost(_session-&gt;dev.parent)
+
+static struct iscsi_if_conn*
+iscsi_if_find_conn(uint64_t key)
+{
+	unsigned long flags;
+	struct iscsi_if_conn *conn;
+
+	spin_lock_irqsave(&amp;connlock, flags);
+	list_for_each_entry(conn, &amp;connlist, conn_list)
+		if (conn-&gt;connh == key) {
+			spin_unlock_irqrestore(&amp;connlock, flags);
+			return conn;
+		}
+	spin_unlock_irqrestore(&amp;connlock, flags);
+	return NULL;
 }
 
-#define iscsi_session_rd_bool_attr(field)				\
-	iscsi_session_show_bool_fn(field)				\
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_bool_##field, NULL);
+static struct iscsi_internal *
+iscsi_if_transport_lookup(struct iscsi_transport *tt)
+{
+	struct iscsi_internal *priv;
+	unsigned long flags;
 
-iscsi_session_rd_bool_attr(initial_r2t);
-iscsi_session_rd_bool_attr(immediate_data);
-iscsi_session_rd_bool_attr(data_pdu_in_order);
-iscsi_session_rd_bool_attr(data_sequence_in_order);
+	spin_lock_irqsave(&amp;iscsi_transport_lock, flags);
+	list_for_each_entry(priv, &amp;iscsi_transports, list) {
+		if (tt == priv-&gt;iscsi_transport) {
+			spin_unlock_irqrestore(&amp;iscsi_transport_lock, flags);
+			return priv;
+		}
+	}
+	spin_unlock_irqrestore(&amp;iscsi_transport_lock, flags);
+	return NULL;
+}
 
-#define iscsi_session_show_digest_fn(field)				\
-									\
-static ssize_t								\
-show_##field(struct class_device *cdev, char *buf)			\
-{									\
-	struct scsi_target *starget = transport_class_to_starget(cdev);	\
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);	\
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt); \
-									\
-	if (i-&gt;fnt-&gt;get_##field)					\
-		i-&gt;fnt-&gt;get_##field(starget);				\
-									\
-	if (iscsi_##field(starget))					\
-		return sprintf(buf, "CRC32C\n");			\
-	return sprintf(buf, "None\n");					\
+static inline struct list_head *skb_to_lh(struct sk_buff *skb)
+{
+	return (struct list_head *)&amp;skb-&gt;cb;
 }
 
-#define iscsi_session_rd_digest_attr(field)				\
-	iscsi_session_show_digest_fn(field)				\
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
+static void*
+mempool_zone_alloc_skb(unsigned int gfp_mask, void *pool_data)
+{
+	struct mempool_zone *zone = pool_data;
 
-iscsi_session_rd_digest_attr(header_digest);
-iscsi_session_rd_digest_attr(data_digest);
+	return alloc_skb(zone-&gt;size, gfp_mask);
+}
 
-static ssize_t
-show_port(struct class_device *cdev, char *buf)
+static void
+mempool_zone_free_skb(void *element, void *pool_data)
 {
-	struct scsi_target *starget = transport_class_to_starget(cdev);
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt);
+	kfree_skb(element);
+}
 
-	if (i-&gt;fnt-&gt;get_port)
-		i-&gt;fnt-&gt;get_port(starget);
+static void
+mempool_zone_complete(struct mempool_zone *zone)
+{
+	unsigned long flags;
+	struct list_head *lh, *n;
 
-	return snprintf(buf, 20, "%hu\n", ntohs(iscsi_port(starget)));
+	spin_lock_irqsave(&amp;zone-&gt;freelock, flags);
+	list_for_each_safe(lh, n, &amp;zone-&gt;freequeue) {
+		struct sk_buff *skb = (struct sk_buff *)((char *)lh -
+				offsetof(struct sk_buff, cb));
+		if (!skb_shared(skb)) {
+			list_del(skb_to_lh(skb));
+			mempool_free(skb, zone-&gt;pool);
+			atomic_dec(&amp;zone-&gt;allocated);
+		}
+	}
+	spin_unlock_irqrestore(&amp;zone-&gt;freelock, flags);
 }
-static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 
-static ssize_t
-show_ip_address(struct class_device *cdev, char *buf)
+static int
+mempool_zone_init(struct mempool_zone *zp, unsigned max, unsigned size,
+		unsigned hiwat)
 {
-	struct scsi_target *starget = transport_class_to_starget(cdev);
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt);
-
-	if (i-&gt;fnt-&gt;get_ip_address)
-		i-&gt;fnt-&gt;get_ip_address(starget);
-
-	if (iscsi_addr_type(starget) == AF_INET)
-		return sprintf(buf, "%u.%u.%u.%u\n",
-			       NIPQUAD(iscsi_sin_addr(starget)));
-	else if(iscsi_addr_type(starget) == AF_INET6)
-		return sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
-			       NIP6(iscsi_sin6_addr(starget)));
-	return -EINVAL;
+	zp-&gt;pool = mempool_create(max, mempool_zone_alloc_skb,
+				  mempool_zone_free_skb, zp);
+	if (!zp-&gt;pool)
+		return -ENOMEM;
+
+	zp-&gt;size = size;
+	zp-&gt;hiwat = hiwat;
+
+	INIT_LIST_HEAD(&amp;zp-&gt;freequeue);
+	spin_lock_init(&amp;zp-&gt;freelock);
+	atomic_set(&amp;zp-&gt;allocated, 0);
+
+	return 0;
 }
-static CLASS_DEVICE_ATTR(ip_address, S_IRUGO, show_ip_address, NULL);
 
-static ssize_t
-show_isid(struct class_device *cdev, char *buf)
+
+static struct sk_buff*
+mempool_zone_get_skb(struct mempool_zone *zone)
 {
-	struct scsi_target *starget = transport_class_to_starget(cdev);
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt);
+	struct sk_buff *skb;
+
+	skb = mempool_alloc(zone-&gt;pool, GFP_ATOMIC);
+	if (skb)
+		atomic_inc(&amp;zone-&gt;allocated);
+	return skb;
+}
 
-	if (i-&gt;fnt-&gt;get_isid)
-		i-&gt;fnt-&gt;get_isid(starget);
+static int
+iscsi_unicast_skb(struct mempool_zone *zone, struct sk_buff *skb)
+{
+	unsigned long flags;
+	int rc;
+
+	skb_get(skb);
+	rc = netlink_unicast(nls, skb, daemon_pid, MSG_DONTWAIT);
+	if (rc &lt; 0) {
+		mempool_free(skb, zone-&gt;pool);
+		printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
+		return rc;
+	}
 
-	return sprintf(buf, "%02x%02x%02x%02x%02x%02x\n",
-		       iscsi_isid(starget)[0], iscsi_isid(starget)[1],
-		       iscsi_isid(starget)[2], iscsi_isid(starget)[3],
-		       iscsi_isid(starget)[4], iscsi_isid(starget)[5]);
+	spin_lock_irqsave(&amp;zone-&gt;freelock, flags);
+	list_add(skb_to_lh(skb), &amp;zone-&gt;freequeue);
+	spin_unlock_irqrestore(&amp;zone-&gt;freelock, flags);
+
+	return 0;
 }
-static CLASS_DEVICE_ATTR(isid, S_IRUGO, show_isid, NULL);
 
-/*
- * This is used for iSCSI names. Normally, we follow
- * the transport class convention of having the lld
- * set the field, but in these cases the value is
- * too large.
- */
-#define iscsi_session_show_str_fn(field)				\
-									\
-static ssize_t								\
-show_session_str_##field(struct class_device *cdev, char *buf)		\
-{									\
-	ssize_t ret = 0;						\
-	struct scsi_target *starget = transport_class_to_starget(cdev);	\
-	struct Scsi_Host *shost = dev_to_shost(starget-&gt;dev.parent);	\
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt); \
-									\
-	if (i-&gt;fnt-&gt;get_##field)					\
-		ret = i-&gt;fnt-&gt;get_##field(starget, buf, PAGE_SIZE);	\
-	return ret;							\
+int iscsi_recv_pdu(iscsi_connh_t connh, struct iscsi_hdr *hdr,
+		   char *data, uint32_t data_size)
+{
+	struct nlmsghdr	*nlh;
+	struct sk_buff *skb;
+	struct iscsi_uevent *ev;
+	struct iscsi_if_conn *conn;
+	char *pdu;
+	int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
+			      data_size);
+
+	conn = iscsi_if_find_conn(connh);
+	BUG_ON(!conn);
+
+	mempool_zone_complete(&amp;conn-&gt;z_pdu);
+
+	skb = mempool_zone_get_skb(&amp;conn-&gt;z_pdu);
+	if (!skb) {
+		iscsi_conn_error(connh, ISCSI_ERR_CONN_FAILED);
+		printk(KERN_ERR "iscsi%d: can not deliver control PDU: OOM\n",
+		       conn-&gt;host-&gt;host_no);
+		return -ENOMEM;
+	}
+
+	nlh = __nlmsg_put(skb, daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
+	ev = NLMSG_DATA(nlh);
+	memset(ev, 0, sizeof(*ev));
+	ev-&gt;transport_handle = iscsi_handle(conn-&gt;transport);
+	ev-&gt;type = ISCSI_KEVENT_RECV_PDU;
+	if (atomic_read(&amp;conn-&gt;z_pdu.allocated) &gt;= conn-&gt;z_pdu.hiwat)
+		ev-&gt;iferror = -ENOMEM;
+	ev-&gt;r.recv_req.conn_handle = connh;
+	pdu = (char*)ev + sizeof(*ev);
+	memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
+	memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
+
+	return iscsi_unicast_skb(&amp;conn-&gt;z_pdu, skb);
+}
+EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
+
+void iscsi_conn_error(iscsi_connh_t connh, enum iscsi_err error)
+{
+	struct nlmsghdr	*nlh;
+	struct sk_buff	*skb;
+	struct iscsi_uevent *ev;
+	struct iscsi_if_conn *conn;
+	int len = NLMSG_SPACE(sizeof(*ev));
+
+	conn = iscsi_if_find_conn(connh);
+	BUG_ON(!conn);
+
+	mempool_zone_complete(&amp;conn-&gt;z_error);
+
+	skb = mempool_zone_get_skb(&amp;conn-&gt;z_error);
+	if (!skb) {
+		printk(KERN_ERR "iscsi%d: gracefully ignored conn error (%d)\n",
+		       conn-&gt;host-&gt;host_no, error);
+		return;
+	}
+
+	nlh = __nlmsg_put(skb, daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
+	ev = NLMSG_DATA(nlh);
+	ev-&gt;transport_handle = iscsi_handle(conn-&gt;transport);
+	ev-&gt;type = ISCSI_KEVENT_CONN_ERROR;
+	if (atomic_read(&amp;conn-&gt;z_error.allocated) &gt;= conn-&gt;z_error.hiwat)
+		ev-&gt;iferror = -ENOMEM;
+	ev-&gt;r.connerror.error = error;
+	ev-&gt;r.connerror.conn_handle = connh;
+
+	iscsi_unicast_skb(&amp;conn-&gt;z_error, skb);
+
+	printk(KERN_INFO "iscsi%d: detected conn error (%d)\n",
+	       conn-&gt;host-&gt;host_no, error);
 }
+EXPORT_SYMBOL_GPL(iscsi_conn_error);
 
-#define iscsi_session_rd_str_attr(field)				\
-	iscsi_session_show_str_fn(field)				\
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_str_##field, NULL);
+static int
+iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
+		      void *payload, int size)
+{
+	struct sk_buff	*skb;
+	struct nlmsghdr	*nlh;
+	int len = NLMSG_SPACE(size);
+	int flags = multi ? NLM_F_MULTI : 0;
+	int t = done ? NLMSG_DONE : type;
 
-iscsi_session_rd_str_attr(target_name);
-iscsi_session_rd_str_attr(target_alias);
+	mempool_zone_complete(&amp;z_reply);
+
+	skb = mempool_zone_get_skb(&amp;z_reply);
+	/*
+	 * FIXME:
+	 * user is supposed to react on iferror == -ENOMEM;
+	 * see iscsi_if_rx().
+	 */
+	BUG_ON(!skb);
+
+	nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
+	nlh-&gt;nlmsg_flags = flags;
+	memcpy(NLMSG_DATA(nlh), payload, size);
+	return iscsi_unicast_skb(&amp;z_reply, skb);
+}
 
 /*
- * iSCSI host attrs
+ * iSCSI Session's hostdata organization:
+ *
+ *    *------------------* &lt;== host-&gt;hostdata
+ *    | transport        |
+ *    |------------------| &lt;== iscsi_hostdata(host-&gt;hostdata)
+ *    | transport's data |
+ *    |------------------| &lt;== hostdata_session(host-&gt;hostdata)
+ *    | interface's data |
+ *    *------------------*
  */
 
+#define hostdata_privsize(_t)	(sizeof(unsigned long) + _t-&gt;hostdata_size + \
+				 _t-&gt;hostdata_size % sizeof(unsigned long) + \
+				 sizeof(struct iscsi_if_session))
+
+#define hostdata_session(_hostdata) ((void*)_hostdata + sizeof(unsigned long) + \
+			((struct iscsi_transport *) \
+			 iscsi_ptr(*(uint64_t *)_hostdata))-&gt;hostdata_size)
+
+static void iscsi_if_session_dev_release(struct device *dev)
+{
+	struct iscsi_if_session *session = iscsi_dev_to_if_session(dev);
+	struct iscsi_transport *transport = session-&gt;transport;
+	struct Scsi_Host *shost = iscsi_if_session_to_shost(session);
+	struct iscsi_if_conn *conn, *tmp;
+	unsigned long flags;
+
+	/* now free connections */
+	spin_lock_irqsave(&amp;connlock, flags);
+	list_for_each_entry_safe(conn, tmp, &amp;session-&gt;connections,
+				 session_list) {
+		list_del(&amp;conn-&gt;session_list);
+		mempool_destroy(conn-&gt;z_pdu.pool);
+		mempool_destroy(conn-&gt;z_error.pool);
+		kfree(conn);
+	}
+	spin_unlock_irqrestore(&amp;connlock, flags);
+	scsi_host_put(shost);
+	module_put(transport-&gt;owner);
+}
+
+static int
+iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
+{
+	struct iscsi_transport *transport = priv-&gt;iscsi_transport;
+	struct iscsi_if_session *session;
+	struct Scsi_Host *shost;
+	unsigned long flags;
+	int error;
+
+	if (!try_module_get(transport-&gt;owner))
+		return -EPERM;
+
+	shost = scsi_host_alloc(transport-&gt;host_template,
+				hostdata_privsize(transport));
+	if (!shost) {
+		ev-&gt;r.c_session_ret.session_handle = iscsi_handle(NULL);
+		printk(KERN_ERR "iscsi: can not allocate SCSI host for "
+		       "session\n");
+		error = -ENOMEM;
+		goto out_module_put;
+	}
+	shost-&gt;max_id = 1;
+	shost-&gt;max_channel = 0;
+	shost-&gt;max_lun = transport-&gt;max_lun;
+	shost-&gt;max_cmd_len = transport-&gt;max_cmd_len;
+	shost-&gt;transportt = &amp;priv-&gt;t;
+
+	/* store struct iscsi_transport in hostdata */
+	*(uint64_t*)shost-&gt;hostdata = ev-&gt;transport_handle;
+
+	ev-&gt;r.c_session_ret.session_handle = transport-&gt;create_session(
+					ev-&gt;u.c_session.initial_cmdsn, shost);
+	if (ev-&gt;r.c_session_ret.session_handle == iscsi_handle(NULL)) {
+		error = 0;
+		goto out_host_put;
+	}
+
+	/* host_no becomes assigned SID */
+	ev-&gt;r.c_session_ret.sid = shost-&gt;host_no;
+	/* initialize session */
+	session = hostdata_session(shost-&gt;hostdata);
+	INIT_LIST_HEAD(&amp;session-&gt;connections);
+	INIT_LIST_HEAD(&amp;session-&gt;list);
+	session-&gt;sessionh = ev-&gt;r.c_session_ret.session_handle;
+	session-&gt;transport = transport;
+
+	error = scsi_add_host(shost, NULL);
+	if (error)
+		goto out_destroy_session;
+
+	/*
+	 * this is released in the dev's release function)
+	 */
+	scsi_host_get(shost);
+	snprintf(session-&gt;dev.bus_id, BUS_ID_SIZE, "session%u", shost-&gt;host_no);
+	session-&gt;dev.parent = &amp;shost-&gt;shost_gendev;
+	session-&gt;dev.release = iscsi_if_session_dev_release;
+	error = device_register(&amp;session-&gt;dev);
+	if (error) {
+		printk(KERN_ERR "iscsi: could not register session%d's dev\n",
+		       shost-&gt;host_no);
+		goto out_remove_host;
+	}
+	transport_register_device(&amp;session-&gt;dev);
+
+	/* add this session to the list of active sessions */
+	spin_lock_irqsave(&amp;priv-&gt;session_lock, flags);
+	list_add(&amp;session-&gt;list, &amp;priv-&gt;sessions);
+	spin_unlock_irqrestore(&amp;priv-&gt;session_lock, flags);
+
+	return 0;
+
+out_remove_host:
+	scsi_remove_host(shost);
+out_destroy_session:
+	transport-&gt;destroy_session(ev-&gt;r.c_session_ret.session_handle);
+	ev-&gt;r.c_session_ret.session_handle = iscsi_handle(NULL);
+out_host_put:
+	scsi_host_put(shost);
+out_module_put:
+	module_put(transport-&gt;owner);
+	return error;
+}
+
+static int
+iscsi_if_destroy_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
+{
+	struct iscsi_transport *transport = priv-&gt;iscsi_transport;
+	struct Scsi_Host *shost;
+	struct iscsi_if_session *session;
+	unsigned long flags;
+	struct iscsi_if_conn *conn;
+	int error = 0;
+
+	shost = scsi_host_lookup(ev-&gt;u.d_session.sid);
+	if (shost == ERR_PTR(-ENXIO))
+		return -EEXIST;
+	session = hostdata_session(shost-&gt;hostdata);
+
+	/* check if we have active connections */
+	spin_lock_irqsave(&amp;connlock, flags);
+	list_for_each_entry(conn, &amp;session-&gt;connections, session_list) {
+		if (conn-&gt;active) {
+			printk(KERN_ERR "iscsi%d: can not destroy session: "
+			       "has active connection (%p)\n",
+			       shost-&gt;host_no, iscsi_ptr(conn-&gt;connh));
+			spin_unlock_irqrestore(&amp;connlock, flags);
+			error = EIO;
+			goto out_release_ref;
+		}
+	}
+	spin_unlock_irqrestore(&amp;connlock, flags);
+
+	scsi_remove_host(shost);
+	transport-&gt;destroy_session(ev-&gt;u.d_session.session_handle);
+	transport_unregister_device(&amp;session-&gt;dev);
+	device_unregister(&amp;session-&gt;dev);
+
+	/* remove this session from the list of active sessions */
+	spin_lock_irqsave(&amp;priv-&gt;session_lock, flags);
+	list_del(&amp;session-&gt;list);
+	spin_unlock_irqrestore(&amp;priv-&gt;session_lock, flags);
+
+	/* ref from host alloc */
+	scsi_host_put(shost);
+out_release_ref:
+	/* ref from host lookup */
+	scsi_host_put(shost);
+	return error;
+}
+
+static void iscsi_if_conn_dev_release(struct device *dev)
+{
+	struct iscsi_if_conn *conn = iscsi_dev_to_if_conn(dev);
+	struct Scsi_Host *shost = conn-&gt;host;
+
+	scsi_host_put(shost);
+}
+
+static int
+iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
+{
+	struct iscsi_if_session *session;
+	struct Scsi_Host *shost;
+	struct iscsi_if_conn *conn;
+	unsigned long flags;
+	int error;
+
+	shost = scsi_host_lookup(ev-&gt;u.c_conn.sid);
+	if (shost == ERR_PTR(-ENXIO))
+		return -EEXIST;
+	session = hostdata_session(shost-&gt;hostdata);
+
+	conn = kmalloc(sizeof(struct iscsi_if_conn), GFP_KERNEL);
+	if (!conn) {
+		error = -ENOMEM;
+		goto out_release_ref;
+	}
+	memset(conn, 0, sizeof(struct iscsi_if_conn));
+	INIT_LIST_HEAD(&amp;conn-&gt;session_list);
+	INIT_LIST_HEAD(&amp;conn-&gt;conn_list);
+	conn-&gt;host = shost;
+	conn-&gt;transport = transport;
+
+	error = mempool_zone_init(&amp;conn-&gt;z_pdu, Z_MAX_PDU,
+			NLMSG_SPACE(sizeof(struct iscsi_uevent) +
+				    sizeof(struct iscsi_hdr) +
+				    DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH),
+			Z_HIWAT_PDU);
+	if (error) {
+		printk(KERN_ERR "iscsi%d: can not allocate pdu zone for new "
+		       "conn\n", shost-&gt;host_no);
+		goto out_free_conn;
+	}
+	error = mempool_zone_init(&amp;conn-&gt;z_error, Z_MAX_ERROR,
+			NLMSG_SPACE(sizeof(struct iscsi_uevent)),
+			Z_HIWAT_ERROR);
+	if (error) {
+		printk(KERN_ERR "iscsi%d: can not allocate error zone for "
+		       "new conn\n", shost-&gt;host_no);
+		goto out_free_pdu_pool;
+	}
+
+	ev-&gt;r.handle = transport-&gt;create_conn(ev-&gt;u.c_conn.session_handle,
+					ev-&gt;u.c_conn.cid);
+	if (!ev-&gt;r.handle) {
+		error = -ENODEV;
+		goto out_free_error_pool;
+	}
+
+	conn-&gt;connh = ev-&gt;r.handle;
+
+	/*
+	 * this is released in the dev's release function
+	 */
+	if (!scsi_host_get(shost))
+		goto out_destroy_conn;
+	snprintf(conn-&gt;dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
+		 shost-&gt;host_no, ev-&gt;u.c_conn.cid);
+	conn-&gt;dev.parent = &amp;session-&gt;dev;
+	conn-&gt;dev.release = iscsi_if_conn_dev_release;
+	error = device_register(&amp;conn-&gt;dev);
+	if (error) {
+		printk(KERN_ERR "iscsi%d: could not register connections%u "
+		       "dev\n", shost-&gt;host_no, ev-&gt;u.c_conn.cid);
+		goto out_release_parent_ref;
+	}
+	transport_register_device(&amp;conn-&gt;dev);
+
+	spin_lock_irqsave(&amp;connlock, flags);
+	list_add(&amp;conn-&gt;conn_list, &amp;connlist);
+	list_add(&amp;conn-&gt;session_list, &amp;session-&gt;connections);
+	conn-&gt;active = 1;
+	spin_unlock_irqrestore(&amp;connlock, flags);
+
+	scsi_host_put(shost);
+	return 0;
+
+out_release_parent_ref:
+	scsi_host_put(shost);
+out_destroy_conn:
+	transport-&gt;destroy_conn(ev-&gt;r.handle);
+out_free_error_pool:
+	mempool_destroy(conn-&gt;z_error.pool);
+out_free_pdu_pool:
+	mempool_destroy(conn-&gt;z_pdu.pool);
+out_free_conn:
+	kfree(conn);
+out_release_ref:
+	scsi_host_put(shost);
+	return error;
+}
+
+static int
+iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
+{
+	unsigned long flags;
+	struct iscsi_if_conn *conn;
+
+	conn = iscsi_if_find_conn(ev-&gt;u.d_conn.conn_handle);
+	if (!conn)
+		return -EEXIST;
+
+	transport-&gt;destroy_conn(ev-&gt;u.d_conn.conn_handle);
+
+	spin_lock_irqsave(&amp;connlock, flags);
+	conn-&gt;active = 0;
+	list_del(&amp;conn-&gt;conn_list);
+	spin_unlock_irqrestore(&amp;connlock, flags);
+
+	transport_unregister_device(&amp;conn-&gt;dev);
+	device_unregister(&amp;conn-&gt;dev);
+	return 0;
+}
+
+static int
+iscsi_if_get_stats(struct iscsi_transport *transport, struct sk_buff *skb,
+		   struct nlmsghdr *nlh)
+{
+	struct iscsi_uevent *ev = NLMSG_DATA(nlh);
+	struct iscsi_stats *stats;
+	struct sk_buff *skbstat;
+	struct iscsi_if_conn *conn;
+	struct nlmsghdr	*nlhstat;
+	struct iscsi_uevent *evstat;
+	int len = NLMSG_SPACE(sizeof(*ev) +
+			      sizeof(struct iscsi_stats) +
+			      sizeof(struct iscsi_stats_custom) *
+			      ISCSI_STATS_CUSTOM_MAX);
+	int err = 0;
+
+	conn = iscsi_if_find_conn(ev-&gt;u.get_stats.conn_handle);
+	if (!conn)
+		return -EEXIST;
+
+	do {
+		int actual_size;
+
+		mempool_zone_complete(&amp;conn-&gt;z_pdu);
+
+		skbstat = mempool_zone_get_skb(&amp;conn-&gt;z_pdu);
+		if (!skbstat) {
+			printk(KERN_ERR "iscsi%d: can not deliver stats: OOM\n",
+			       conn-&gt;host-&gt;host_no);
+			return -ENOMEM;
+		}
+
+		nlhstat = __nlmsg_put(skbstat, daemon_pid, 0, 0,
+				      (len - sizeof(*nlhstat)), 0);
+		evstat = NLMSG_DATA(nlhstat);
+		memset(evstat, 0, sizeof(*evstat));
+		evstat-&gt;transport_handle = iscsi_handle(conn-&gt;transport);
+		evstat-&gt;type = nlh-&gt;nlmsg_type;
+		if (atomic_read(&amp;conn-&gt;z_pdu.allocated) &gt;= conn-&gt;z_pdu.hiwat)
+			evstat-&gt;iferror = -ENOMEM;
+		evstat-&gt;u.get_stats.conn_handle =
+			ev-&gt;u.get_stats.conn_handle;
+		stats = (struct iscsi_stats *)
+			((char*)evstat + sizeof(*evstat));
+		memset(stats, 0, sizeof(*stats));
+
+		transport-&gt;get_stats(ev-&gt;u.get_stats.conn_handle, stats);
+		actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
+					  sizeof(struct iscsi_stats) +
+					  sizeof(struct iscsi_stats_custom) *
+					  stats-&gt;custom_length);
+		actual_size -= sizeof(*nlhstat);
+		actual_size = NLMSG_LENGTH(actual_size);
+		skb_trim(skb, NLMSG_ALIGN(actual_size));
+		nlhstat-&gt;nlmsg_len = actual_size;
+
+		err = iscsi_unicast_skb(&amp;conn-&gt;z_pdu, skbstat);
+	} while (err &lt; 0 &amp;&amp; err != -ECONNREFUSED);
+
+	return err;
+}
+
+static int
+iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
+{
+	int err = 0;
+	struct iscsi_uevent *ev = NLMSG_DATA(nlh);
+	struct iscsi_transport *transport = NULL;
+	struct iscsi_internal *priv;
+
+	if (NETLINK_CREDS(skb)-&gt;uid)
+		return -EPERM;
+
+	priv = iscsi_if_transport_lookup(iscsi_ptr(ev-&gt;transport_handle));
+	if (!priv)
+		return -EINVAL;
+	transport = priv-&gt;iscsi_transport;
+
+	daemon_pid = NETLINK_CREDS(skb)-&gt;pid;
+
+	switch (nlh-&gt;nlmsg_type) {
+	case ISCSI_UEVENT_CREATE_SESSION:
+		err = iscsi_if_create_session(priv, ev);
+		break;
+	case ISCSI_UEVENT_DESTROY_SESSION:
+		err = iscsi_if_destroy_session(priv, ev);
+		break;
+	case ISCSI_UEVENT_CREATE_CONN:
+		err = iscsi_if_create_conn(transport, ev);
+		break;
+	case ISCSI_UEVENT_DESTROY_CONN:
+		err = iscsi_if_destroy_conn(transport, ev);
+		break;
+	case ISCSI_UEVENT_BIND_CONN:
+		if (!iscsi_if_find_conn(ev-&gt;u.b_conn.conn_handle))
+			return -EEXIST;
+		ev-&gt;r.retcode = transport-&gt;bind_conn(
+			ev-&gt;u.b_conn.session_handle,
+			ev-&gt;u.b_conn.conn_handle,
+			ev-&gt;u.b_conn.transport_fd,
+			ev-&gt;u.b_conn.is_leading);
+		break;
+	case ISCSI_UEVENT_SET_PARAM:
+		if (!iscsi_if_find_conn(ev-&gt;u.set_param.conn_handle))
+			return -EEXIST;
+		ev-&gt;r.retcode = transport-&gt;set_param(
+			ev-&gt;u.set_param.conn_handle,
+			ev-&gt;u.set_param.param, ev-&gt;u.set_param.value);
+		break;
+	case ISCSI_UEVENT_START_CONN:
+		if (!iscsi_if_find_conn(ev-&gt;u.start_conn.conn_handle))
+			return -EEXIST;
+		ev-&gt;r.retcode = transport-&gt;start_conn(
+			ev-&gt;u.start_conn.conn_handle);
+		break;
+	case ISCSI_UEVENT_STOP_CONN:
+		if (!iscsi_if_find_conn(ev-&gt;u.stop_conn.conn_handle))
+			return -EEXIST;
+		transport-&gt;stop_conn(ev-&gt;u.stop_conn.conn_handle,
+			ev-&gt;u.stop_conn.flag);
+		break;
+	case ISCSI_UEVENT_SEND_PDU:
+		if (!iscsi_if_find_conn(ev-&gt;u.send_pdu.conn_handle))
+			return -EEXIST;
+		ev-&gt;r.retcode = transport-&gt;send_pdu(
+		       ev-&gt;u.send_pdu.conn_handle,
+		       (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
+		       (char*)ev + sizeof(*ev) + ev-&gt;u.send_pdu.hdr_size,
+			ev-&gt;u.send_pdu.data_size);
+		break;
+	case ISCSI_UEVENT_GET_STATS:
+		err = iscsi_if_get_stats(transport, skb, nlh);
+		break;
+	default:
+		err = -EINVAL;
+		break;
+	}
+
+	return err;
+}
+
+/* Get message from skb (based on rtnetlink_rcv_skb).  Each message is
+ * processed by iscsi_if_recv_msg.  Malformed skbs with wrong length are
+ * discarded silently.  */
+static void
+iscsi_if_rx(struct sock *sk, int len)
+{
+	struct sk_buff *skb;
+
+	down(&amp;rx_queue_sema);
+	while ((skb = skb_dequeue(&amp;sk-&gt;sk_receive_queue)) != NULL) {
+		while (skb-&gt;len &gt;= NLMSG_SPACE(0)) {
+			int err;
+			uint32_t rlen;
+			struct nlmsghdr	*nlh;
+			struct iscsi_uevent *ev;
+
+			nlh = (struct nlmsghdr *)skb-&gt;data;
+			if (nlh-&gt;nlmsg_len &lt; sizeof(*nlh) ||
+			    skb-&gt;len &lt; nlh-&gt;nlmsg_len) {
+				break;
+			}
+			ev = NLMSG_DATA(nlh);
+			rlen = NLMSG_ALIGN(nlh-&gt;nlmsg_len);
+			if (rlen &gt; skb-&gt;len)
+				rlen = skb-&gt;len;
+			err = iscsi_if_recv_msg(skb, nlh);
+			if (err) {
+				ev-&gt;type = ISCSI_KEVENT_IF_ERROR;
+				ev-&gt;iferror = err;
+			}
+			do {
+				/*
+				 * special case for GET_STATS:
+				 * on success - sending reply and stats from
+				 * inside of if_recv_msg(),
+				 * on error - fall through.
+				 */
+				if (ev-&gt;type == ISCSI_UEVENT_GET_STATS &amp;&amp; !err)
+					break;
+				err = iscsi_if_send_reply(
+					NETLINK_CREDS(skb)-&gt;pid, nlh-&gt;nlmsg_seq,
+					nlh-&gt;nlmsg_type, 0, 0, ev, sizeof(*ev));
+				if (atomic_read(&amp;z_reply.allocated) &gt;=
+						z_reply.hiwat)
+					ev-&gt;iferror = -ENOMEM;
+			} while (err &lt; 0 &amp;&amp; err != -ECONNREFUSED);
+			skb_pull(skb, rlen);
+		}
+		kfree_skb(skb);
+	}
+	up(&amp;rx_queue_sema);
+}
+
 /*
- * Again, this is used for iSCSI names. Normally, we follow
- * the transport class convention of having the lld set
- * the field, but in these cases the value is too large.
+ * iSCSI connection attrs
  */
-#define iscsi_host_show_str_fn(field)					\
-									\
+#define iscsi_conn_int_attr_show(param, format)				\
 static ssize_t								\
-show_host_str_##field(struct class_device *cdev, char *buf)		\
+show_conn_int_param_##param(struct class_device *cdev, char *buf)	\
 {									\
-	int ret = 0;							\
-	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
-	struct iscsi_internal *i = to_iscsi_internal(shost-&gt;transportt); \
+	uint32_t value = 0;						\
+	struct iscsi_if_conn *conn = iscsi_cdev_to_if_conn(cdev);	\
+	struct iscsi_internal *priv;					\
 									\
-	if (i-&gt;fnt-&gt;get_##field)					\
-		ret = i-&gt;fnt-&gt;get_##field(shost, buf, PAGE_SIZE);	\
-	return ret;							\
+	priv = to_iscsi_internal(conn-&gt;host-&gt;transportt);		\
+	if (priv-&gt;param_mask &amp; (1 &lt;&lt; param))				\
+		priv-&gt;iscsi_transport-&gt;get_param(conn-&gt;connh, param, &amp;value); \
+	return snprintf(buf, 20, format"\n", value);			\
 }
 
-#define iscsi_host_rd_str_attr(field)					\
-	iscsi_host_show_str_fn(field)					\
-static CLASS_DEVICE_ATTR(field, S_IRUGO, show_host_str_##field, NULL);
+#define iscsi_conn_int_attr(field, param, format)			\
+	iscsi_conn_int_attr_show(param, format)				\
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_conn_int_param_##param, NULL);
+
+iscsi_conn_int_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH, "%u");
+iscsi_conn_int_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH, "%u");
+iscsi_conn_int_attr(header_digest, ISCSI_PARAM_HDRDGST_EN, "%d");
+iscsi_conn_int_attr(data_digest, ISCSI_PARAM_DATADGST_EN, "%d");
+iscsi_conn_int_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN, "%d");
+iscsi_conn_int_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN, "%d");
 
-iscsi_host_rd_str_attr(initiator_name);
-iscsi_host_rd_str_attr(initiator_alias);
+/*
+ * iSCSI session attrs
+ */
+#define iscsi_session_int_attr_show(param, format)			\
+static ssize_t								\
+show_session_int_param_##param(struct class_device *cdev, char *buf)	\
+{									\
+	uint32_t value = 0;						\
+	struct iscsi_if_session *session = iscsi_cdev_to_if_session(cdev); \
+	struct Scsi_Host *shost = iscsi_if_session_to_shost(session);	\
+	struct iscsi_internal *priv = to_iscsi_internal(shost-&gt;transportt); \
+	struct iscsi_if_conn *conn = NULL;				\
+	unsigned long  flags;						\
+									\
+	spin_lock_irqsave(&amp;connlock, flags);				\
+	if (!list_empty(&amp;session-&gt;connections))				\
+		conn = list_entry(session-&gt;connections.next,		\
+				  struct iscsi_if_conn, session_list);	\
+	spin_unlock_irqrestore(&amp;connlock, flags);			\
+									\
+	if (conn &amp;&amp; (priv-&gt;param_mask &amp; (1 &lt;&lt; param)))			\
+		priv-&gt;iscsi_transport-&gt;get_param(conn-&gt;connh, param, &amp;value);\
+	return snprintf(buf, 20, format"\n", value);			\
+}
 
-#define SETUP_SESSION_RD_ATTR(field)					\
-	if (i-&gt;fnt-&gt;show_##field) {					\
-		i-&gt;session_attrs[count] = &amp;class_device_attr_##field;	\
+#define iscsi_session_int_attr(field, param, format)			\
+	iscsi_session_int_attr_show(param, format)			\
+static CLASS_DEVICE_ATTR(field, S_IRUGO, show_session_int_param_##param, NULL);
+
+iscsi_session_int_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, "%d");
+iscsi_session_int_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, "%hu");
+iscsi_session_int_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, "%d");
+iscsi_session_int_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, "%u");
+iscsi_session_int_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, "%u");
+iscsi_session_int_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, "%d");
+iscsi_session_int_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, "%d");
+iscsi_session_int_attr(erl, ISCSI_PARAM_ERL, "%d");
+
+#define SETUP_SESSION_RD_ATTR(field, param)				\
+	if (priv-&gt;param_mask &amp; (1 &lt;&lt; param)) {				\
+		priv-&gt;session_attrs[count] = &amp;class_device_attr_##field;\
 		count++;						\
 	}
 
-#define SETUP_HOST_RD_ATTR(field)					\
-	if (i-&gt;fnt-&gt;show_##field) {					\
-		i-&gt;host_attrs[count] = &amp;class_device_attr_##field;	\
+#define SETUP_CONN_RD_ATTR(field, param)				\
+	if (priv-&gt;param_mask &amp; (1 &lt;&lt; param)) {				\
+		priv-&gt;conn_attrs[count] = &amp;class_device_attr_##field;	\
 		count++;						\
 	}
 
-static int iscsi_host_match(struct attribute_container *cont,
-			  struct device *dev)
+static int iscsi_is_session_dev(const struct device *dev)
 {
+	return dev-&gt;release == iscsi_if_session_dev_release;
+}
+
+static int iscsi_session_match(struct attribute_container *cont,
+			   struct device *dev)
+{
+	struct iscsi_if_session *session;
 	struct Scsi_Host *shost;
-	struct iscsi_internal *i;
+	struct iscsi_internal *priv;
+
+	if (!iscsi_is_session_dev(dev))
+		return 0;
 
-	if (!scsi_is_host_device(dev))
+	session = iscsi_dev_to_if_session(dev);
+	shost = iscsi_if_session_to_shost(session);
+	if (!shost-&gt;transportt)
 		return 0;
 
-	shost = dev_to_shost(dev);
-	if (!shost-&gt;transportt  || shost-&gt;transportt-&gt;host_attrs.ac.class
-	    != &amp;iscsi_host_class.class)
+	priv = to_iscsi_internal(shost-&gt;transportt);
+	if (priv-&gt;session_cont.ac.class != &amp;iscsi_session_class.class)
 		return 0;
 
-	i = to_iscsi_internal(shost-&gt;transportt);
-	
-	return &amp;i-&gt;t.host_attrs.ac == cont;
+	return &amp;priv-&gt;session_cont.ac == cont;
 }
 
-static int iscsi_target_match(struct attribute_container *cont,
-			    struct device *dev)
+static int iscsi_is_conn_dev(const struct device *dev)
 {
+	return dev-&gt;release == iscsi_if_conn_dev_release;
+}
+
+static int iscsi_conn_match(struct attribute_container *cont,
+			   struct device *dev)
+{
+	struct iscsi_if_conn *conn;
 	struct Scsi_Host *shost;
-	struct iscsi_internal *i;
+	struct iscsi_internal *priv;
 
-	if (!scsi_is_target_device(dev))
+	if (!iscsi_is_conn_dev(dev))
 		return 0;
 
-	shost = dev_to_shost(dev-&gt;parent);
-	if (!shost-&gt;transportt  || shost-&gt;transportt-&gt;host_attrs.ac.class
-	    != &amp;iscsi_host_class.class)
+	conn = iscsi_dev_to_if_conn(dev);
+	shost = conn-&gt;host;
+	if (!shost-&gt;transportt)
 		return 0;
 
-	i = to_iscsi_internal(shost-&gt;transportt);
-	
-	return &amp;i-&gt;t.target_attrs.ac == cont;
-}
-
-struct scsi_transport_template *
-iscsi_attach_transport(struct iscsi_function_template *fnt)
-{
-	struct iscsi_internal *i = kmalloc(sizeof(struct iscsi_internal),
-					   GFP_KERNEL);
-	int count = 0;
-
-	if (unlikely(!i))
-		return NULL;
-
-	memset(i, 0, sizeof(struct iscsi_internal));
-	i-&gt;fnt = fnt;
-
-	i-&gt;t.target_attrs.ac.attrs = &amp;i-&gt;session_attrs[0];
-	i-&gt;t.target_attrs.ac.class = &amp;iscsi_transport_class.class;
-	i-&gt;t.target_attrs.ac.match = iscsi_target_match;
-	transport_container_register(&amp;i-&gt;t.target_attrs);
-	i-&gt;t.target_size = sizeof(struct iscsi_class_session);
-
-	SETUP_SESSION_RD_ATTR(tsih);
-	SETUP_SESSION_RD_ATTR(isid);
-	SETUP_SESSION_RD_ATTR(header_digest);
-	SETUP_SESSION_RD_ATTR(data_digest);
-	SETUP_SESSION_RD_ATTR(target_name);
-	SETUP_SESSION_RD_ATTR(target_alias);
-	SETUP_SESSION_RD_ATTR(port);
-	SETUP_SESSION_RD_ATTR(tpgt);
-	SETUP_SESSION_RD_ATTR(ip_address);
-	SETUP_SESSION_RD_ATTR(initial_r2t);
-	SETUP_SESSION_RD_ATTR(immediate_data);
-	SETUP_SESSION_RD_ATTR(max_recv_data_segment_len);
-	SETUP_SESSION_RD_ATTR(max_burst_len);
-	SETUP_SESSION_RD_ATTR(first_burst_len);
-	SETUP_SESSION_RD_ATTR(def_time2wait);
-	SETUP_SESSION_RD_ATTR(def_time2retain);
-	SETUP_SESSION_RD_ATTR(max_outstanding_r2t);
-	SETUP_SESSION_RD_ATTR(data_pdu_in_order);
-	SETUP_SESSION_RD_ATTR(data_sequence_in_order);
-	SETUP_SESSION_RD_ATTR(erl);
+	priv = to_iscsi_internal(shost-&gt;transportt);
+	if (priv-&gt;conn_cont.ac.class != &amp;iscsi_connection_class.class)
+		return 0;
 
-	BUG_ON(count &gt; ISCSI_SESSION_ATTRS);
-	i-&gt;session_attrs[count] = NULL;
+	return &amp;priv-&gt;conn_cont.ac == cont;
+}
+
+int iscsi_register_transport(struct iscsi_transport *tt)
+{
+	struct iscsi_internal *priv;
+	unsigned long flags;
+	int count = 0, err;
+
+	BUG_ON(!tt);
+
+	priv = iscsi_if_transport_lookup(tt);
+	if (priv)
+		return -EEXIST;
+
+	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+	memset(priv, 0, sizeof(*priv));
+	INIT_LIST_HEAD(&amp;priv-&gt;list);
+	INIT_LIST_HEAD(&amp;priv-&gt;sessions);
+	spin_lock_init(&amp;priv-&gt;session_lock);
+	priv-&gt;iscsi_transport = tt;
+
+	priv-&gt;cdev.class = &amp;iscsi_transport_class;
+	snprintf(priv-&gt;cdev.class_id, BUS_ID_SIZE, "%s", tt-&gt;name);
+	err = class_device_register(&amp;priv-&gt;cdev);
+	if (err)
+		goto free_priv;
+
+	err = sysfs_create_group(&amp;priv-&gt;cdev.kobj, &amp;iscsi_transport_group);
+	if (err)
+		goto unregister_cdev;
+
+	/* setup parameters mask */
+	priv-&gt;param_mask = 0xFFFFFFFF;
+	if (!(tt-&gt;caps &amp; CAP_MULTI_R2T))
+		priv-&gt;param_mask &amp;= ~(1 &lt;&lt; ISCSI_PARAM_MAX_R2T);
+	if (!(tt-&gt;caps &amp; CAP_HDRDGST))
+		priv-&gt;param_mask &amp;= ~(1 &lt;&lt; ISCSI_PARAM_HDRDGST_EN);
+	if (!(tt-&gt;caps &amp; CAP_DATADGST))
+		priv-&gt;param_mask &amp;= ~(1 &lt;&lt; ISCSI_PARAM_DATADGST_EN);
+	if (!(tt-&gt;caps &amp; CAP_MARKERS)) {
+		priv-&gt;param_mask &amp;= ~(1 &lt;&lt; ISCSI_PARAM_IFMARKER_EN);
+		priv-&gt;param_mask &amp;= ~(1 &lt;&lt; ISCSI_PARAM_OFMARKER_EN);
+	}
 
-	i-&gt;t.host_attrs.ac.attrs = &amp;i-&gt;host_attrs[0];
-	i-&gt;t.host_attrs.ac.class = &amp;iscsi_host_class.class;
-	i-&gt;t.host_attrs.ac.match = iscsi_host_match;
-	transport_container_register(&amp;i-&gt;t.host_attrs);
-	i-&gt;t.host_size = 0;
+	/* connection parameters */
+	priv-&gt;conn_cont.ac.attrs = &amp;priv-&gt;conn_attrs[0];
+	priv-&gt;conn_cont.ac.class = &amp;iscsi_connection_class.class;
+	priv-&gt;conn_cont.ac.match = iscsi_conn_match;
+	transport_container_register(&amp;priv-&gt;conn_cont);
+
+	SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
+	SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
+	SETUP_CONN_RD_ATTR(header_digest, ISCSI_PARAM_HDRDGST_EN);
+	SETUP_CONN_RD_ATTR(data_digest, ISCSI_PARAM_DATADGST_EN);
+	SETUP_CONN_RD_ATTR(ifmarker, ISCSI_PARAM_IFMARKER_EN);
+	SETUP_CONN_RD_ATTR(ofmarker, ISCSI_PARAM_OFMARKER_EN);
 
+	BUG_ON(count &gt; ISCSI_CONN_ATTRS);
+	priv-&gt;conn_attrs[count] = NULL;
 	count = 0;
-	SETUP_HOST_RD_ATTR(initiator_name);
-	SETUP_HOST_RD_ATTR(initiator_alias);
 
-	BUG_ON(count &gt; ISCSI_HOST_ATTRS);
-	i-&gt;host_attrs[count] = NULL;
+	/* session parameters */
+	priv-&gt;session_cont.ac.attrs = &amp;priv-&gt;session_attrs[0];
+	priv-&gt;session_cont.ac.class = &amp;iscsi_session_class.class;
+	priv-&gt;session_cont.ac.match = iscsi_session_match;
+	transport_container_register(&amp;priv-&gt;session_cont);
+
+	SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN);
+	SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T);
+	SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_PARAM_IMM_DATA_EN);
+	SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_PARAM_FIRST_BURST);
+	SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_PARAM_MAX_BURST);
+	SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN);
+	SETUP_SESSION_RD_ATTR(data_seq_in_order,ISCSI_PARAM_DATASEQ_INORDER_EN)
+	SETUP_SESSION_RD_ATTR(erl, ISCSI_PARAM_ERL);
 
-	return &amp;i-&gt;t;
+	BUG_ON(count &gt; ISCSI_SESSION_ATTRS);
+	priv-&gt;session_attrs[count] = NULL;
+
+	spin_lock_irqsave(&amp;iscsi_transport_lock, flags);
+	list_add(&amp;priv-&gt;list, &amp;iscsi_transports);
+	spin_unlock_irqrestore(&amp;iscsi_transport_lock, flags);
+
+	printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt-&gt;name);
+	return 0;
+
+unregister_cdev:
+	class_device_unregister(&amp;priv-&gt;cdev);
+free_priv:
+	kfree(priv);
+	return err;
 }
+EXPORT_SYMBOL_GPL(iscsi_register_transport);
+
+int iscsi_unregister_transport(struct iscsi_transport *tt)
+{
+	struct iscsi_internal *priv;
+	unsigned long flags;
+
+	BUG_ON(!tt);
+
+	down(&amp;rx_queue_sema);
+
+	priv = iscsi_if_transport_lookup(tt);
+	BUG_ON (!priv);
 
-EXPORT_SYMBOL(iscsi_attach_transport);
+	spin_lock_irqsave(&amp;priv-&gt;session_lock, flags);
+	if (!list_empty(&amp;priv-&gt;sessions)) {
+		spin_unlock_irqrestore(&amp;priv-&gt;session_lock, flags);
+		up(&amp;rx_queue_sema);
+		return -EPERM;
+	}
+	spin_unlock_irqrestore(&amp;priv-&gt;session_lock, flags);
+
+	spin_lock_irqsave(&amp;iscsi_transport_lock, flags);
+	list_del(&amp;priv-&gt;list);
+	spin_unlock_irqrestore(&amp;iscsi_transport_lock, flags);
+
+	transport_container_unregister(&amp;priv-&gt;conn_cont);
+	transport_container_unregister(&amp;priv-&gt;session_cont);
+
+	sysfs_remove_group(&amp;priv-&gt;cdev.kobj, &amp;iscsi_transport_group);
+	class_device_unregister(&amp;priv-&gt;cdev);
+	up(&amp;rx_queue_sema);
 
-void iscsi_release_transport(struct scsi_transport_template *t)
+	return 0;
+}
+EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
+
+static int
+iscsi_rcv_nl_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-	struct iscsi_internal *i = to_iscsi_internal(t);
+	struct netlink_notify *n = ptr;
 
-	transport_container_unregister(&amp;i-&gt;t.target_attrs);
-	transport_container_unregister(&amp;i-&gt;t.host_attrs);
-  
-	kfree(i);
+	if (event == NETLINK_URELEASE &amp;&amp;
+	    n-&gt;protocol == NETLINK_ISCSI &amp;&amp; n-&gt;pid) {
+		struct iscsi_if_conn *conn;
+		unsigned long flags;
+
+		mempool_zone_complete(&amp;z_reply);
+		spin_lock_irqsave(&amp;connlock, flags);
+		list_for_each_entry(conn, &amp;connlist, conn_list) {
+			mempool_zone_complete(&amp;conn-&gt;z_error);
+			mempool_zone_complete(&amp;conn-&gt;z_pdu);
+		}
+		spin_unlock_irqrestore(&amp;connlock, flags);
+	}
+
+	return NOTIFY_DONE;
 }
 
-EXPORT_SYMBOL(iscsi_release_transport);
+static struct notifier_block iscsi_nl_notifier = {
+	.notifier_call	= iscsi_rcv_nl_event,
+};
 
 static __init int iscsi_transport_init(void)
 {
-	int err = transport_class_register(&amp;iscsi_transport_class);
+	int err;
 
+	err = class_register(&amp;iscsi_transport_class);
 	if (err)
 		return err;
-	return transport_class_register(&amp;iscsi_host_class);
+
+	err = transport_class_register(&amp;iscsi_connection_class);
+	if (err)
+		goto unregister_transport_class;
+
+	err = transport_class_register(&amp;iscsi_session_class);
+	if (err)
+		goto unregister_conn_class;
+
+	err = netlink_register_notifier(&amp;iscsi_nl_notifier);
+	if (err)
+		goto unregister_session_class;
+
+	nls = netlink_kernel_create(NETLINK_ISCSI, iscsi_if_rx);
+	if (!nls) {
+		err = -ENOBUFS;
+		goto unregister_notifier;
+	}
+
+	err = mempool_zone_init(&amp;z_reply, Z_MAX_REPLY,
+		NLMSG_SPACE(sizeof(struct iscsi_uevent)), Z_HIWAT_REPLY);
+	if (!err)
+		return 0;
+
+	sock_release(nls-&gt;sk_socket);
+unregister_notifier:
+	netlink_unregister_notifier(&amp;iscsi_nl_notifier);
+unregister_session_class:
+	transport_class_unregister(&amp;iscsi_session_class);
+unregister_conn_class:
+	transport_class_unregister(&amp;iscsi_connection_class);
+unregister_transport_class:
+	class_unregister(&amp;iscsi_transport_class);
+	return err;
 }
 
 static void __exit iscsi_transport_exit(void)
 {
-	transport_class_unregister(&amp;iscsi_host_class);
-	transport_class_unregister(&amp;iscsi_transport_class);
+	mempool_destroy(z_reply.pool);
+	sock_release(nls-&gt;sk_socket);
+	netlink_unregister_notifier(&amp;iscsi_nl_notifier);
+	transport_class_unregister(&amp;iscsi_connection_class);
+	transport_class_unregister(&amp;iscsi_session_class);
+	class_unregister(&amp;iscsi_transport_class);
 }
 
 module_init(iscsi_transport_init);
 module_exit(iscsi_transport_exit);
 
-MODULE_AUTHOR("Mike Christie");
-MODULE_DESCRIPTION("iSCSI Transport Attributes");
+MODULE_AUTHOR("Mike Christie &lt;michaelc@cs.wisc.edu&gt;, "
+	      "Dmitry Yusupov &lt;dmitry_yus@yahoo.com&gt;, "
+	      "Alex Aizman &lt;itn780@yahoo.com&gt;");
+MODULE_DESCRIPTION("iSCSI Transport Interface");
 MODULE_LICENSE("GPL");
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
new file mode 100644
--- /dev/null
+++ b/include/scsi/iscsi_if.h
@@ -0,0 +1,245 @@
+/*
+ * iSCSI User/Kernel Shares (Defines, Constants, Protocol definitions, etc)
+ *
+ * Copyright (C) 2005 Dmitry Yusupov
+ * Copyright (C) 2005 Alex Aizman
+ * maintained by open-iscsi@googlegroups.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * See the file COPYING included with this distribution for more details.
+ */
+
+#ifndef ISCSI_IF_H
+#define ISCSI_IF_H
+
+#include &lt;scsi/iscsi_proto.h&gt;
+
+#define UEVENT_BASE			10
+#define KEVENT_BASE			100
+#define ISCSI_ERR_BASE			1000
+
+enum iscsi_uevent_e {
+	ISCSI_UEVENT_UNKNOWN		= 0,
+
+	/* down events */
+	ISCSI_UEVENT_CREATE_SESSION	= UEVENT_BASE + 1,
+	ISCSI_UEVENT_DESTROY_SESSION	= UEVENT_BASE + 2,
+	ISCSI_UEVENT_CREATE_CONN	= UEVENT_BASE + 3,
+	ISCSI_UEVENT_DESTROY_CONN	= UEVENT_BASE + 4,
+	ISCSI_UEVENT_BIND_CONN		= UEVENT_BASE + 5,
+	ISCSI_UEVENT_SET_PARAM		= UEVENT_BASE + 6,
+	ISCSI_UEVENT_START_CONN		= UEVENT_BASE + 7,
+	ISCSI_UEVENT_STOP_CONN		= UEVENT_BASE + 8,
+	ISCSI_UEVENT_SEND_PDU		= UEVENT_BASE + 9,
+	ISCSI_UEVENT_GET_STATS		= UEVENT_BASE + 10,
+	ISCSI_UEVENT_GET_PARAM		= UEVENT_BASE + 11,
+
+	/* up events */
+	ISCSI_KEVENT_RECV_PDU		= KEVENT_BASE + 1,
+	ISCSI_KEVENT_CONN_ERROR		= KEVENT_BASE + 2,
+	ISCSI_KEVENT_IF_ERROR		= KEVENT_BASE + 3,
+};
+
+struct iscsi_uevent {
+	uint32_t type; /* k/u events type */
+	uint32_t iferror; /* carries interface or resource errors */
+	uint64_t transport_handle;
+
+	union {
+		/* messages u -&gt; k */
+		struct msg_create_session {
+			uint32_t	initial_cmdsn;
+		} c_session;
+		struct msg_destroy_session {
+			uint64_t	session_handle;
+			uint32_t	sid;
+		} d_session;
+		struct msg_create_conn {
+			uint64_t	session_handle;
+			uint32_t	cid;
+			uint32_t	sid;
+		} c_conn;
+		struct msg_bind_conn {
+			uint64_t	session_handle;
+			uint64_t	conn_handle;
+			uint32_t	transport_fd;
+			uint32_t	is_leading;
+		} b_conn;
+		struct msg_destroy_conn {
+			uint64_t	conn_handle;
+			uint32_t	cid;
+		} d_conn;
+		struct msg_send_pdu {
+			uint32_t	hdr_size;
+			uint32_t	data_size;
+			uint64_t	conn_handle;
+		} send_pdu;
+		struct msg_set_param {
+			uint64_t	conn_handle;
+			uint32_t	param; /* enum iscsi_param */
+			uint32_t	value;
+		} set_param;
+		struct msg_start_conn {
+			uint64_t	conn_handle;
+		} start_conn;
+		struct msg_stop_conn {
+			uint64_t	conn_handle;
+			uint32_t	flag;
+		} stop_conn;
+		struct msg_get_stats {
+			uint64_t	conn_handle;
+		} get_stats;
+	} u;
+	union {
+		/* messages k -&gt; u */
+		uint64_t		handle;
+		int			retcode;
+		struct msg_create_session_ret {
+			uint64_t	session_handle;
+			uint32_t	sid;
+		} c_session_ret;
+		struct msg_recv_req {
+			uint64_t	recv_handle;
+			uint64_t	conn_handle;
+		} recv_req;
+		struct msg_conn_error {
+			uint64_t	conn_handle;
+			uint32_t	error; /* enum iscsi_err */
+		} connerror;
+	} r;
+} __attribute__ ((aligned (sizeof(uint64_t))));
+
+/*
+ * Common error codes
+ */
+enum iscsi_err {
+	ISCSI_OK			= 0,
+
+	ISCSI_ERR_DATASN		= ISCSI_ERR_BASE + 1,
+	ISCSI_ERR_DATA_OFFSET		= ISCSI_ERR_BASE + 2,
+	ISCSI_ERR_MAX_CMDSN		= ISCSI_ERR_BASE + 3,
+	ISCSI_ERR_EXP_CMDSN		= ISCSI_ERR_BASE + 4,
+	ISCSI_ERR_BAD_OPCODE		= ISCSI_ERR_BASE + 5,
+	ISCSI_ERR_DATALEN		= ISCSI_ERR_BASE + 6,
+	ISCSI_ERR_AHSLEN		= ISCSI_ERR_BASE + 7,
+	ISCSI_ERR_PROTO			= ISCSI_ERR_BASE + 8,
+	ISCSI_ERR_LUN			= ISCSI_ERR_BASE + 9,
+	ISCSI_ERR_BAD_ITT		= ISCSI_ERR_BASE + 10,
+	ISCSI_ERR_CONN_FAILED		= ISCSI_ERR_BASE + 11,
+	ISCSI_ERR_R2TSN			= ISCSI_ERR_BASE + 12,
+	ISCSI_ERR_SESSION_FAILED	= ISCSI_ERR_BASE + 13,
+	ISCSI_ERR_HDR_DGST		= ISCSI_ERR_BASE + 14,
+	ISCSI_ERR_DATA_DGST		= ISCSI_ERR_BASE + 15,
+	ISCSI_ERR_PARAM_NOT_FOUND	= ISCSI_ERR_BASE + 16
+};
+
+/*
+ * iSCSI Parameters (RFC3720)
+ */
+enum iscsi_param {
+	ISCSI_PARAM_MAX_RECV_DLENGTH	= 0,
+	ISCSI_PARAM_MAX_XMIT_DLENGTH	= 1,
+	ISCSI_PARAM_HDRDGST_EN		= 2,
+	ISCSI_PARAM_DATADGST_EN		= 3,
+	ISCSI_PARAM_INITIAL_R2T_EN	= 4,
+	ISCSI_PARAM_MAX_R2T		= 5,
+	ISCSI_PARAM_IMM_DATA_EN		= 6,
+	ISCSI_PARAM_FIRST_BURST		= 7,
+	ISCSI_PARAM_MAX_BURST		= 8,
+	ISCSI_PARAM_PDU_INORDER_EN	= 9,
+	ISCSI_PARAM_DATASEQ_INORDER_EN	= 10,
+	ISCSI_PARAM_ERL			= 11,
+	ISCSI_PARAM_IFMARKER_EN		= 12,
+	ISCSI_PARAM_OFMARKER_EN		= 13,
+};
+#define ISCSI_PARAM_MAX			14
+
+typedef uint64_t iscsi_sessionh_t;	/* iSCSI Data-Path session handle */
+typedef uint64_t iscsi_connh_t;		/* iSCSI Data-Path connection handle */
+
+#define iscsi_ptr(_handle) ((void*)(unsigned long)_handle)
+#define iscsi_handle(_ptr) ((uint64_t)(unsigned long)_ptr)
+#define iscsi_hostdata(_hostdata) ((void*)_hostdata + sizeof(unsigned long))
+
+/*
+ * These flags presents iSCSI Data-Path capabilities.
+ */
+#define CAP_RECOVERY_L0		0x1
+#define CAP_RECOVERY_L1		0x2
+#define CAP_RECOVERY_L2		0x4
+#define CAP_MULTI_R2T		0x8
+#define CAP_HDRDGST		0x10
+#define CAP_DATADGST		0x20
+#define CAP_MULTI_CONN		0x40
+#define CAP_TEXT_NEGO		0x80
+#define CAP_MARKERS		0x100
+
+/*
+ * These flags describes reason of stop_conn() call
+ */
+#define STOP_CONN_TERM		0x1
+#define STOP_CONN_SUSPEND	0x2
+#define STOP_CONN_RECOVER	0x3
+
+#define ISCSI_STATS_CUSTOM_MAX		32
+#define ISCSI_STATS_CUSTOM_DESC_MAX	64
+struct iscsi_stats_custom {
+	char desc[ISCSI_STATS_CUSTOM_DESC_MAX];
+	uint64_t value;
+};
+
+/*
+ * struct iscsi_stats - iSCSI Statistics (iSCSI MIB)
+ *
+ * Note: this structure contains counters collected on per-connection basis.
+ */
+struct iscsi_stats {
+	/* octets */
+	uint64_t txdata_octets;
+	uint64_t rxdata_octets;
+
+	/* xmit pdus */
+	uint32_t noptx_pdus;
+	uint32_t scsicmd_pdus;
+	uint32_t tmfcmd_pdus;
+	uint32_t login_pdus;
+	uint32_t text_pdus;
+	uint32_t dataout_pdus;
+	uint32_t logout_pdus;
+	uint32_t snack_pdus;
+
+	/* recv pdus */
+	uint32_t noprx_pdus;
+	uint32_t scsirsp_pdus;
+	uint32_t tmfrsp_pdus;
+	uint32_t textrsp_pdus;
+	uint32_t datain_pdus;
+	uint32_t logoutrsp_pdus;
+	uint32_t r2t_pdus;
+	uint32_t async_pdus;
+	uint32_t rjt_pdus;
+
+	/* errors */
+	uint32_t digest_err;
+	uint32_t timeout_err;
+
+	/*
+	 * iSCSI Custom Statistics support, i.e. Transport could
+	 * extend existing MIB statistics with its own specific statistics
+	 * up to ISCSI_STATS_CUSTOM_MAX
+	 */
+	uint32_t custom_length;
+	struct iscsi_stats_custom custom[0]
+		__attribute__ ((aligned (sizeof(uint64_t))));
+};
+
+#endif
diff --git a/include/scsi/iscsi_proto.h b/include/scsi/iscsi_proto.h
new file mode 100644
--- /dev/null
+++ b/include/scsi/iscsi_proto.h
@@ -0,0 +1,566 @@
+/*
+ * RFC 3720 (iSCSI) protocol data types
+ *
+ * Copyright (C) 2005 Dmitry Yusupov
+ * Copyright (C) 2005 Alex Aizman
+ * maintained by open-iscsi@googlegroups.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * See the file COPYING included with this distribution for more details.
+ */
+
+#ifndef ISCSI_PROTO_H
+#define ISCSI_PROTO_H
+
+#define ISCSI_VERSION_STR	"0.3"
+#define ISCSI_DATE_STR		"22-Apr-2005"
+#define ISCSI_DRAFT20_VERSION	0x00
+
+/* default iSCSI listen port for incoming connections */
+#define ISCSI_LISTEN_PORT	3260
+
+/* Padding word length */
+#define PAD_WORD_LEN		4
+
+/*
+ * useful common(control and data pathes) macro
+ */
+#define ntoh24(p) (((p)[0] &lt;&lt; 16) | ((p)[1] &lt;&lt; 8) | ((p)[2]))
+#define hton24(p, v) { \
+        p[0] = (((v) &gt;&gt; 16) &amp; 0xFF); \
+        p[1] = (((v) &gt;&gt; 8) &amp; 0xFF); \
+        p[2] = ((v) &amp; 0xFF); \
+}
+#define zero_data(p) {p[0]=0;p[1]=0;p[2]=0;}
+
+/*
+ * iSCSI Template Message Header
+ */
+struct iscsi_hdr {
+	uint8_t		opcode;
+	uint8_t		flags;		/* Final bit */
+	uint8_t		rsvd2[2];
+	uint8_t		hlength;	/* AHSs total length */
+	uint8_t		dlength[3];	/* Data length */
+	uint8_t		lun[8];
+	__be32		itt;		/* Initiator Task Tag */
+	__be32		ttt;		/* Target Task Tag */
+	__be32		statsn;
+	__be32		exp_statsn;
+	uint8_t		other[16];
+};
+
+/************************* RFC 3720 Begin *****************************/
+
+#define ISCSI_RESERVED_TAG		0xffffffff
+
+/* Opcode encoding bits */
+#define ISCSI_OP_RETRY			0x80
+#define ISCSI_OP_IMMEDIATE		0x40
+#define ISCSI_OPCODE_MASK		0x3F
+
+/* Initiator Opcode values */
+#define ISCSI_OP_NOOP_OUT		0x00
+#define ISCSI_OP_SCSI_CMD		0x01
+#define ISCSI_OP_SCSI_TMFUNC		0x02
+#define ISCSI_OP_LOGIN			0x03
+#define ISCSI_OP_TEXT			0x04
+#define ISCSI_OP_SCSI_DATA_OUT		0x05
+#define ISCSI_OP_LOGOUT			0x06
+#define ISCSI_OP_SNACK			0x10
+
+/* Target Opcode values */
+#define ISCSI_OP_NOOP_IN		0x20
+#define ISCSI_OP_SCSI_CMD_RSP		0x21
+#define ISCSI_OP_SCSI_TMFUNC_RSP	0x22
+#define ISCSI_OP_LOGIN_RSP		0x23
+#define ISCSI_OP_TEXT_RSP		0x24
+#define ISCSI_OP_SCSI_DATA_IN		0x25
+#define ISCSI_OP_LOGOUT_RSP		0x26
+#define ISCSI_OP_R2T			0x31
+#define ISCSI_OP_ASYNC_EVENT		0x32
+#define ISCSI_OP_REJECT			0x3f
+
+/* iSCSI PDU Header */
+struct iscsi_cmd {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2;
+	uint8_t cmdrn;
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32 itt;	/* Initiator Task Tag */
+	__be32 data_length;
+	__be32 cmdsn;
+	__be32 exp_statsn;
+	uint8_t cdb[16];	/* SCSI Command Block */
+	/* Additional Data (Command Dependent) */
+};
+
+/* Command PDU flags */
+#define ISCSI_FLAG_CMD_FINAL		0x80
+#define ISCSI_FLAG_CMD_READ		0x40
+#define ISCSI_FLAG_CMD_WRITE		0x20
+#define ISCSI_FLAG_CMD_ATTR_MASK	0x07	/* 3 bits */
+
+/* SCSI Command Attribute values */
+#define ISCSI_ATTR_UNTAGGED		0
+#define ISCSI_ATTR_SIMPLE		1
+#define ISCSI_ATTR_ORDERED		2
+#define ISCSI_ATTR_HEAD_OF_QUEUE	3
+#define ISCSI_ATTR_ACA			4
+
+/* SCSI Response Header */
+struct iscsi_cmd_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t response;
+	uint8_t cmd_status;
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	rsvd1;
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	__be32	exp_datasn;
+	__be32	bi_residual_count;
+	__be32	residual_count;
+	/* Response or Sense Data (optional) */
+};
+
+/* Command Response PDU flags */
+#define ISCSI_FLAG_CMD_BIDI_OVERFLOW	0x10
+#define ISCSI_FLAG_CMD_BIDI_UNDERFLOW	0x08
+#define ISCSI_FLAG_CMD_OVERFLOW		0x04
+#define ISCSI_FLAG_CMD_UNDERFLOW	0x02
+
+/* iSCSI Status values. Valid if Rsp Selector bit is not set */
+#define ISCSI_STATUS_CMD_COMPLETED	0
+#define ISCSI_STATUS_TARGET_FAILURE	1
+#define ISCSI_STATUS_SUBSYS_FAILURE	2
+
+/* Asynchronous Event Header */
+struct iscsi_async {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[2];
+	uint8_t rsvd3;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	uint8_t rsvd4[8];
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	uint8_t async_event;
+	uint8_t async_vcode;
+	__be16	param1;
+	__be16	param2;
+	__be16	param3;
+	uint8_t rsvd5[4];
+};
+
+/* iSCSI Event Codes */
+#define ISCSI_ASYNC_MSG_SCSI_EVENT			0
+#define ISCSI_ASYNC_MSG_REQUEST_LOGOUT			1
+#define ISCSI_ASYNC_MSG_DROPPING_CONNECTION		2
+#define ISCSI_ASYNC_MSG_DROPPING_ALL_CONNECTIONS	3
+#define ISCSI_ASYNC_MSG_PARAM_NEGOTIATION		4
+#define ISCSI_ASYNC_MSG_VENDOR_SPECIFIC			255
+
+/* NOP-Out Message */
+struct iscsi_nopout {
+	uint8_t opcode;
+	uint8_t flags;
+	__be16	rsvd2;
+	uint8_t rsvd3;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	ttt;	/* Target Transfer Tag */
+	__be32	cmdsn;
+	__be32	exp_statsn;
+	uint8_t rsvd4[16];
+};
+
+/* NOP-In Message */
+struct iscsi_nopin {
+	uint8_t opcode;
+	uint8_t flags;
+	__be16	rsvd2;
+	uint8_t rsvd3;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	ttt;	/* Target Transfer Tag */
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	uint8_t rsvd4[12];
+};
+
+/* SCSI Task Management Message Header */
+struct iscsi_tm {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd1[2];
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	rtt;	/* Reference Task Tag */
+	__be32	cmdsn;
+	__be32	exp_statsn;
+	__be32	refcmdsn;
+	__be32	exp_datasn;
+	uint8_t rsvd2[8];
+};
+
+#define ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK	0x7F
+
+/* Function values */
+#define ISCSI_TM_FUNC_ABORT_TASK		1
+#define ISCSI_TM_FUNC_ABORT_TASK_SET		2
+#define ISCSI_TM_FUNC_CLEAR_ACA			3
+#define ISCSI_TM_FUNC_CLEAR_TASK_SET		4
+#define ISCSI_TM_FUNC_LOGICAL_UNIT_RESET	5
+#define ISCSI_TM_FUNC_TARGET_WARM_RESET		6
+#define ISCSI_TM_FUNC_TARGET_COLD_RESET		7
+#define ISCSI_TM_FUNC_TASK_REASSIGN		8
+
+/* SCSI Task Management Response Header */
+struct iscsi_tm_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t response;	/* see Response values below */
+	uint8_t qualifier;
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd2[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	rtt;	/* Reference Task Tag */
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	uint8_t rsvd3[12];
+};
+
+/* Response values */
+#define SCSI_TCP_TM_RESP_COMPLETE	0x00
+#define SCSI_TCP_TM_RESP_NO_TASK	0x01
+#define SCSI_TCP_TM_RESP_NO_LUN		0x02
+#define SCSI_TCP_TM_RESP_TASK_ALLEGIANT	0x03
+#define SCSI_TCP_TM_RESP_NO_FAILOVER	0x04
+#define SCSI_TCP_TM_RESP_NOT_SUPPORTED	0x05
+#define SCSI_TCP_TM_RESP_AUTH_FAILED	0x06
+#define SCSI_TCP_TM_RESP_REJECTED	0xff
+
+/* Ready To Transfer Header */
+struct iscsi_r2t_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[2];
+	uint8_t	hlength;
+	uint8_t	dlength[3];
+	uint8_t lun[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	ttt;	/* Target Transfer Tag */
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	__be32	r2tsn;
+	__be32	data_offset;
+	__be32	data_length;
+};
+
+/* SCSI Data Hdr */
+struct iscsi_data {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[2];
+	uint8_t rsvd3;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32	itt;
+	__be32	ttt;
+	__be32	rsvd4;
+	__be32	exp_statsn;
+	__be32	rsvd5;
+	__be32	datasn;
+	__be32	offset;
+	__be32	rsvd6;
+	/* Payload */
+};
+
+/* SCSI Data Response Hdr */
+struct iscsi_data_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2;
+	uint8_t cmd_status;
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t lun[8];
+	__be32	itt;
+	__be32	ttt;
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	__be32	datasn;
+	__be32	offset;
+	__be32	residual_count;
+};
+
+/* Data Response PDU flags */
+#define ISCSI_FLAG_DATA_ACK		0x40
+#define ISCSI_FLAG_DATA_OVERFLOW	0x04
+#define ISCSI_FLAG_DATA_UNDERFLOW	0x02
+#define ISCSI_FLAG_DATA_STATUS		0x01
+
+/* Text Header */
+struct iscsi_text {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[2];
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd4[8];
+	__be32	itt;
+	__be32	ttt;
+	__be32	cmdsn;
+	__be32	exp_statsn;
+	uint8_t rsvd5[16];
+	/* Text - key=value pairs */
+};
+
+#define ISCSI_FLAG_TEXT_CONTINUE	0x40
+
+/* Text Response Header */
+struct iscsi_text_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[2];
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd4[8];
+	__be32	itt;
+	__be32	ttt;
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	uint8_t rsvd5[12];
+	/* Text Response - key:value pairs */
+};
+
+/* Login Header */
+struct iscsi_login {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t max_version;	/* Max. version supported */
+	uint8_t min_version;	/* Min. version supported */
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t isid[6];	/* Initiator Session ID */
+	__be16	tsih;	/* Target Session Handle */
+	__be32	itt;	/* Initiator Task Tag */
+	__be16	cid;
+	__be16	rsvd3;
+	__be32	cmdsn;
+	__be32	exp_statsn;
+	uint8_t rsvd5[16];
+};
+
+/* Login PDU flags */
+#define ISCSI_FLAG_LOGIN_TRANSIT		0x80
+#define ISCSI_FLAG_LOGIN_CONTINUE		0x40
+#define ISCSI_FLAG_LOGIN_CURRENT_STAGE_MASK	0x0C	/* 2 bits */
+#define ISCSI_FLAG_LOGIN_NEXT_STAGE_MASK	0x03	/* 2 bits */
+
+#define ISCSI_LOGIN_CURRENT_STAGE(flags) \
+	((flags &amp; ISCSI_FLAG_LOGIN_CURRENT_STAGE_MASK) &gt;&gt; 2)
+#define ISCSI_LOGIN_NEXT_STAGE(flags) \
+	(flags &amp; ISCSI_FLAG_LOGIN_NEXT_STAGE_MASK)
+
+/* Login Response Header */
+struct iscsi_login_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t max_version;	/* Max. version supported */
+	uint8_t active_version;	/* Active version */
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t isid[6];	/* Initiator Session ID */
+	__be16	tsih;	/* Target Session Handle */
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	rsvd3;
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	uint8_t status_class;	/* see Login RSP ststus classes below */
+	uint8_t status_detail;	/* see Login RSP Status details below */
+	uint8_t rsvd4[10];
+};
+
+/* Login stage (phase) codes for CSG, NSG */
+#define ISCSI_INITIAL_LOGIN_STAGE		-1
+#define ISCSI_SECURITY_NEGOTIATION_STAGE	0
+#define ISCSI_OP_PARMS_NEGOTIATION_STAGE	1
+#define ISCSI_FULL_FEATURE_PHASE		3
+
+/* Login Status response classes */
+#define ISCSI_STATUS_CLS_SUCCESS		0x00
+#define ISCSI_STATUS_CLS_REDIRECT		0x01
+#define ISCSI_STATUS_CLS_INITIATOR_ERR		0x02
+#define ISCSI_STATUS_CLS_TARGET_ERR		0x03
+
+/* Login Status response detail codes */
+/* Class-0 (Success) */
+#define ISCSI_LOGIN_STATUS_ACCEPT		0x00
+
+/* Class-1 (Redirection) */
+#define ISCSI_LOGIN_STATUS_TGT_MOVED_TEMP	0x01
+#define ISCSI_LOGIN_STATUS_TGT_MOVED_PERM	0x02
+
+/* Class-2 (Initiator Error) */
+#define ISCSI_LOGIN_STATUS_INIT_ERR		0x00
+#define ISCSI_LOGIN_STATUS_AUTH_FAILED		0x01
+#define ISCSI_LOGIN_STATUS_TGT_FORBIDDEN	0x02
+#define ISCSI_LOGIN_STATUS_TGT_NOT_FOUND	0x03
+#define ISCSI_LOGIN_STATUS_TGT_REMOVED		0x04
+#define ISCSI_LOGIN_STATUS_NO_VERSION		0x05
+#define ISCSI_LOGIN_STATUS_ISID_ERROR		0x06
+#define ISCSI_LOGIN_STATUS_MISSING_FIELDS	0x07
+#define ISCSI_LOGIN_STATUS_CONN_ADD_FAILED	0x08
+#define ISCSI_LOGIN_STATUS_NO_SESSION_TYPE	0x09
+#define ISCSI_LOGIN_STATUS_NO_SESSION		0x0a
+#define ISCSI_LOGIN_STATUS_INVALID_REQUEST	0x0b
+
+/* Class-3 (Target Error) */
+#define ISCSI_LOGIN_STATUS_TARGET_ERROR		0x00
+#define ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE	0x01
+#define ISCSI_LOGIN_STATUS_NO_RESOURCES		0x02
+
+/* Logout Header */
+struct iscsi_logout {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd1[2];
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd2[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be16	cid;
+	uint8_t rsvd3[2];
+	__be32	cmdsn;
+	__be32	exp_statsn;
+	uint8_t rsvd4[16];
+};
+
+/* Logout PDU flags */
+#define ISCSI_FLAG_LOGOUT_REASON_MASK	0x7F
+
+/* logout reason_code values */
+
+#define ISCSI_LOGOUT_REASON_CLOSE_SESSION	0
+#define ISCSI_LOGOUT_REASON_CLOSE_CONNECTION	1
+#define ISCSI_LOGOUT_REASON_RECOVERY		2
+#define ISCSI_LOGOUT_REASON_AEN_REQUEST		3
+
+/* Logout Response Header */
+struct iscsi_logout_rsp {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t response;	/* see Logout response values below */
+	uint8_t rsvd2;
+	uint8_t hlength;
+	uint8_t dlength[3];
+	uint8_t rsvd3[8];
+	__be32	itt;	/* Initiator Task Tag */
+	__be32	rsvd4;
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	__be32	rsvd5;
+	__be16	t2wait;
+	__be16	t2retain;
+	__be32	rsvd6;
+};
+
+/* logout response status values */
+
+#define ISCSI_LOGOUT_SUCCESS			0
+#define ISCSI_LOGOUT_CID_NOT_FOUND		1
+#define ISCSI_LOGOUT_RECOVERY_UNSUPPORTED	2
+#define ISCSI_LOGOUT_CLEANUP_FAILED		3
+
+/* SNACK Header */
+struct iscsi_snack {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t rsvd2[14];
+	__be32	itt;
+	__be32	begrun;
+	__be32	runlength;
+	__be32	exp_statsn;
+	__be32	rsvd3;
+	__be32	exp_datasn;
+	uint8_t rsvd6[8];
+};
+
+/* SNACK PDU flags */
+#define ISCSI_FLAG_SNACK_TYPE_MASK	0x0F	/* 4 bits */
+
+/* Reject Message Header */
+struct iscsi_reject {
+	uint8_t opcode;
+	uint8_t flags;
+	uint8_t reason;
+	uint8_t rsvd2;
+	uint8_t rsvd3;
+	uint8_t dlength[3];
+	uint8_t rsvd4[16];
+	__be32	statsn;
+	__be32	exp_cmdsn;
+	__be32	max_cmdsn;
+	__be32	datasn;
+	uint8_t rsvd5[8];
+	/* Text - Rejected hdr */
+};
+
+/* Reason for Reject */
+#define CMD_BEFORE_LOGIN	1
+#define DATA_DIGEST_ERROR	2
+#define DATA_SNACK_REJECT	3
+#define ISCSI_PROTOCOL_ERROR	4
+#define CMD_NOT_SUPPORTED	5
+#define IMM_CMD_REJECT		6
+#define TASK_IN_PROGRESS	7
+#define INVALID_SNACK		8
+#define BOOKMARK_REJECTED	9
+#define BOOKMARK_NO_RESOURCES	10
+#define NEGOTIATION_RESET	11
+
+/* Max. number of Key=Value pairs in a text message */
+#define MAX_KEY_VALUE_PAIRS	8192
+
+/* maximum length for text keys/values */
+#define KEY_MAXLEN		64
+#define VALUE_MAXLEN		255
+#define TARGET_NAME_MAXLEN	VALUE_MAXLEN
+
+#define DEFAULT_MAX_RECV_DATA_SEGMENT_LENGTH	8192
+
+/************************* RFC 3720 End *****************************/
+
+#endif /* ISCSI_PROTO_H */
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h
--- a/include/scsi/scsi_transport_iscsi.h
+++ b/include/scsi/scsi_transport_iscsi.h
@@ -1,8 +1,10 @@
-/* 
+/*
  * iSCSI transport class definitions
  *
  * Copyright (C) IBM Corporation, 2004
- * Copyright (C) Mike Christie, 2004
+ * Copyright (C) Mike Christie, 2004 - 2005
+ * Copyright (C) Dmitry Yusupov, 2004 - 2005
+ * Copyright (C) Alex Aizman, 2004 - 2005
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,158 +23,64 @@
 #ifndef SCSI_TRANSPORT_ISCSI_H
 #define SCSI_TRANSPORT_ISCSI_H
 
-#include &lt;linux/config.h&gt;
-#include &lt;linux/in6.h&gt;
-#include &lt;linux/in.h&gt;
-
-struct scsi_transport_template;
+#include &lt;scsi/iscsi_if.h&gt;
 
-struct iscsi_class_session {
-	uint8_t isid[6];
-	uint16_t tsih;
-	int header_digest;		/* 1 CRC32, 0 None */
-	int data_digest;		/* 1 CRC32, 0 None */
-	uint16_t tpgt;
-	union {
-		struct in6_addr sin6_addr;
-		struct in_addr sin_addr;
-	} u;
-	sa_family_t addr_type;		/* must be AF_INET or AF_INET6 */
-	uint16_t port;			/* must be in network byte order */
-	int initial_r2t;		/* 1 Yes, 0 No */
-	int immediate_data;		/* 1 Yes, 0 No */
-	uint32_t max_recv_data_segment_len;
-	uint32_t max_burst_len;
-	uint32_t first_burst_len;
-	uint16_t def_time2wait;
-	uint16_t def_time2retain;
-	uint16_t max_outstanding_r2t;
-	int data_pdu_in_order;		/* 1 Yes, 0 No */
-	int data_sequence_in_order;	/* 1 Yes, 0 No */
-	int erl;
+/**
+ * struct iscsi_transport - iSCSI Transport template
+ *
+ * @name:		transport name
+ * @caps:		iSCSI Data-Path capabilities
+ * @create_session:	create new iSCSI session object
+ * @destroy_session:	destroy existing iSCSI session object
+ * @create_conn:	create new iSCSI connection
+ * @bind_conn:		associate this connection with existing iSCSI session
+ *			and specified transport descriptor
+ * @destroy_conn:	destroy inactive iSCSI connection
+ * @set_param:		set iSCSI Data-Path operational parameter
+ * @start_conn:		set connection to be operational
+ * @stop_conn:		suspend/recover/terminate connection
+ * @send_pdu:		send iSCSI PDU, Login, Logout, NOP-Out, Reject, Text.
+ *
+ * Template API provided by iSCSI Transport
+ */
+struct iscsi_transport {
+	struct module *owner;
+	char *name;
+	unsigned int caps;
+	struct scsi_host_template *host_template;
+	int hostdata_size;
+	int max_lun;
+	unsigned int max_conn;
+	unsigned int max_cmd_len;
+	iscsi_sessionh_t (*create_session) (uint32_t initial_cmdsn,
+					    struct Scsi_Host *shost);
+	void (*destroy_session) (iscsi_sessionh_t session);
+	iscsi_connh_t (*create_conn) (iscsi_sessionh_t session, uint32_t cid);
+	int (*bind_conn) (iscsi_sessionh_t session, iscsi_connh_t conn,
+			  uint32_t transport_fd, int is_leading);
+	int (*start_conn) (iscsi_connh_t conn);
+	void (*stop_conn) (iscsi_connh_t conn, int flag);
+	void (*destroy_conn) (iscsi_connh_t conn);
+	int (*set_param) (iscsi_connh_t conn, enum iscsi_param param,
+			  uint32_t value);
+	int (*get_param) (iscsi_connh_t conn, enum iscsi_param param,
+			  uint32_t *value);
+	int (*send_pdu) (iscsi_connh_t conn, struct iscsi_hdr *hdr,
+			 char *data, uint32_t data_size);
+	void (*get_stats) (iscsi_connh_t conn, struct iscsi_stats *stats);
 };
 
 /*
- * accessor macros
+ * transport registration upcalls
  */
-#define iscsi_isid(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;isid)
-#define iscsi_tsih(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;tsih)
-#define iscsi_header_digest(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;header_digest)
-#define iscsi_data_digest(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;data_digest)
-#define iscsi_port(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;port)
-#define iscsi_addr_type(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;addr_type)
-#define iscsi_sin_addr(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;u.sin_addr)
-#define iscsi_sin6_addr(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;u.sin6_addr)
-#define iscsi_tpgt(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;tpgt)
-#define iscsi_initial_r2t(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;initial_r2t)
-#define iscsi_immediate_data(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;immediate_data)
-#define iscsi_max_recv_data_segment_len(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;max_recv_data_segment_len)
-#define iscsi_max_burst_len(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;max_burst_len)
-#define iscsi_first_burst_len(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;first_burst_len)
-#define iscsi_def_time2wait(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;def_time2wait)
-#define iscsi_def_time2retain(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;def_time2retain)
-#define iscsi_max_outstanding_r2t(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;max_outstanding_r2t)
-#define iscsi_data_pdu_in_order(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;data_pdu_in_order)
-#define iscsi_data_sequence_in_order(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;data_sequence_in_order)
-#define iscsi_erl(x) \
-	(((struct iscsi_class_session *)&amp;(x)-&gt;starget_data)-&gt;erl)
+extern int iscsi_register_transport(struct iscsi_transport *tt);
+extern int iscsi_unregister_transport(struct iscsi_transport *tt);
 
 /*
- * The functions by which the transport class and the driver communicate
+ * control plane upcalls
  */
-struct iscsi_function_template {
-	/*
-	 * target attrs
-	 */
-	void (*get_isid)(struct scsi_target *);
-	void (*get_tsih)(struct scsi_target *);
-	void (*get_header_digest)(struct scsi_target *);
-	void (*get_data_digest)(struct scsi_target *);
-	void (*get_port)(struct scsi_target *);
-	void (*get_tpgt)(struct scsi_target *);
-	/*
-	 * In get_ip_address the lld must set the address and
-	 * the address type
-	 */
-	void (*get_ip_address)(struct scsi_target *);
-	/*
-	 * The lld should snprintf the name or alias to the buffer
-	 */
-	ssize_t (*get_target_name)(struct scsi_target *, char *, ssize_t);
-	ssize_t (*get_target_alias)(struct scsi_target *, char *, ssize_t);
-	void (*get_initial_r2t)(struct scsi_target *);
-	void (*get_immediate_data)(struct scsi_target *);
-	void (*get_max_recv_data_segment_len)(struct scsi_target *);
-	void (*get_max_burst_len)(struct scsi_target *);
-	void (*get_first_burst_len)(struct scsi_target *);
-	void (*get_def_time2wait)(struct scsi_target *);
-	void (*get_def_time2retain)(struct scsi_target *);
-	void (*get_max_outstanding_r2t)(struct scsi_target *);
-	void (*get_data_pdu_in_order)(struct scsi_target *);
-	void (*get_data_sequence_in_order)(struct scsi_target *);
-	void (*get_erl)(struct scsi_target *);
-
-	/*
-	 * host atts
-	 */
-
-	/*
-	 * The lld should snprintf the name or alias to the buffer
-	 */
-	ssize_t (*get_initiator_alias)(struct Scsi_Host *, char *, ssize_t);
-	ssize_t (*get_initiator_name)(struct Scsi_Host *, char *, ssize_t);
-	/*
-	 * The driver sets these to tell the transport class it
-	 * wants the attributes displayed in sysfs.  If the show_ flag
-	 * is not set, the attribute will be private to the transport
-	 * class. We could probably just test if a get_ fn was set
-	 * since we only use the values for sysfs but this is how
-	 * fc does it too.
-	 */
-	unsigned long show_isid:1;
-	unsigned long show_tsih:1;
-	unsigned long show_header_digest:1;
-	unsigned long show_data_digest:1;
-	unsigned long show_port:1;
-	unsigned long show_tpgt:1;
-	unsigned long show_ip_address:1;
-	unsigned long show_target_name:1;
-	unsigned long show_target_alias:1;
-	unsigned long show_initial_r2t:1;
-	unsigned long show_immediate_data:1;
-	unsigned long show_max_recv_data_segment_len:1;
-	unsigned long show_max_burst_len:1;
-	unsigned long show_first_burst_len:1;
-	unsigned long show_def_time2wait:1;
-	unsigned long show_def_time2retain:1;
-	unsigned long show_max_outstanding_r2t:1;
-	unsigned long show_data_pdu_in_order:1;
-	unsigned long show_data_sequence_in_order:1;
-	unsigned long show_erl:1;
-	unsigned long show_initiator_name:1;
-	unsigned long show_initiator_alias:1;
-};
-
-struct scsi_transport_template *iscsi_attach_transport(struct iscsi_function_template *);
-void iscsi_release_transport(struct scsi_transport_template *);
+extern void iscsi_conn_error(iscsi_connh_t conn, enum iscsi_err error);
+extern int iscsi_recv_pdu(iscsi_connh_t conn, struct iscsi_hdr *hdr,
+			  char *data, uint32_t data_size);
 
 #endif
</pre></body></html>