[PATCH] iscsi: remove the old iser code

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Signed-off-by: FUJITA Tomonori <fujita.tomonori@xxxxxxxxxxxxx>
---
 usr/iscsi/iscsi_rdma.c | 1748 ------------------------------------------------
 1 files changed, 0 insertions(+), 1748 deletions(-)
 delete mode 100644 usr/iscsi/iscsi_rdma.c

diff --git a/usr/iscsi/iscsi_rdma.c b/usr/iscsi/iscsi_rdma.c
deleted file mode 100644
index 63edebf..0000000
--- a/usr/iscsi/iscsi_rdma.c
+++ /dev/null
@@ -1,1748 +0,0 @@
-/*
- * iSCSI extensions for RDMA (iSER) data path
- *
- * Copyright (C) 2007 Dennis Dalessandro (dennis@xxxxxxx)
- * Copyright (C) 2007 Ananth Devulapalli (ananth@xxxxxxx)
- * Copyright (C) 2007 Pete Wyckoff (pw@xxxxxxx)
- *
- * 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, version 2 of the
- * License.
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <assert.h>
-#include <netdb.h>
-#include <sys/epoll.h>
-#include <infiniband/verbs.h>
-#include <rdma/rdma_cma.h>
-
-#include "util.h"
-#include "iscsid.h"
-
-#if defined(HAVE_VALGRIND) && !defined(NDEBUG)
-#include <valgrind/memcheck.h>
-#else
-#define VALGRIND_MAKE_MEM_DEFINED(addr, len)
-#endif
-
-/*
- * The IB-extended version from the kernel.  Stags and VAs are in
- * big-endian format.
- */
-struct iser_hdr {
-	uint8_t   flags;
-	uint8_t   rsvd[3];
-	uint32_t  write_stag; /* write rkey */
-	uint64_t  write_va;
-	uint32_t  read_stag;  /* read rkey */
-	uint64_t  read_va;
-} __attribute__((packed));
-
-#define ISER_WSV	(0x08)
-#define ISER_RSV	(0x04)
-#define ISCSI_CTRL	(0x10)
-#define ISER_HELLO	(0x20)
-#define ISER_HELLORPLY	(0x30)
-
-struct conn_info;
-
-/*
- * Posted receives for control messages.  All must start with the conn
- * pointer, which will be followed up from a work request during a flush,
- * when it is not known what type to expect.
- */
-struct recvlist {
-	struct conn_info *conn;
-	struct ibv_sge sge;
-	void *buf;
-	struct ibv_recv_wr wr;
-	unsigned long bytes_recvd;
-};
-
-/*
- * Posted sends for control messages.
- */
-struct sendlist {
-	struct conn_info *conn;
-	struct ibv_sge sge;
-	void *buf;
-	struct ibv_send_wr wr;
-	struct list_head list;
-};
-
-/*
- * RDMA read and write operations.
- */
-struct rdmalist {
-	struct conn_info *conn;
-	struct ibv_sge sge;
-	struct ibv_send_wr wr;
-	struct list_head list;
-	struct iscsi_task *task;  /* to get iser_task for remote stag and va */
-};
-
-/*
- * Each SCSI command may have its own RDMA parameters.  These appear on
- * the connection then later are assigned to the particular task to be
- * used when the target responds.
- */
-struct iser_task {
-	/* read and write from the initiator's point of view */
-	uint32_t rem_read_stag, rem_write_stag;
-	uint64_t rem_read_va, rem_write_va;
-	struct iscsi_task task;
-};
-
-struct iser_device;
-
-/*
- * Parallels iscsi_connection.  Adds more fields for iser.
- */
-struct conn_info {
-	struct iscsi_connection iscsi_conn;
-	struct ibv_qp *qp_hndl;
-	struct rdma_cm_id *cma_id;
-	struct iser_device *dev;
-	struct sockaddr_storage peer_addr;  /* initiator address */
-	struct sockaddr_storage self_addr;  /* target address */
-	unsigned int ssize, rsize, max_outst_pdu;
-	unsigned int readb, writeb;
-
-	/* read and write from the initiator's point of view */
-	uint32_t rem_read_stag, rem_write_stag;
-	uint64_t rem_read_va, rem_write_va;
-
-	enum {
-	    LOGIN_PHASE_START,      /* keep 1 send spot and 1 recv posted */
-	    LOGIN_PHASE_LAST_SEND,  /* need 1 more send before ff */
-	    LOGIN_PHASE_FF,         /* full feature */
-	} login_phase;
-
-	void *srbuf;    /* registered space for non-rdma send and recv */
-	void *listbuf;  /* space for the send, recv, rdma list elements */
-	struct ibv_mr *srmr;   /* mr for registered srbuf */
-
-	/* lists of free send, rdma slots */
-	struct list_head sendl, rdmal;
-
-	/* no recvl: just always immediately repost */
-	/* but count so we can drain CQ on close */
-	int recvl_posted;
-
-	struct event_data tx_sched;
-
-	/* login phase resources, freed at full-feature */
-	void *srbuf_login;
-	void *listbuf_login;
-	struct ibv_mr *srmr_login;
-	struct list_head sendl_login, recvl_login;
-
-	/* points to the current recvlist, sendlist items for each conn */
-	struct recvlist *rcv_comm_event;
-	struct sendlist *send_comm_event;
-
-	/* to chain this connection onto the list of those ready to tx */
-	struct list_head conn_tx_ready;
-
-	/* list of all iser conns */
-	struct list_head iser_conn_list;
-
-	/* to consume posted receives after disconnect */
-	int draining;
-
-	/* when free has been called, waits until all posted msgs complete */
-	int freed;
-};
-
-/*
- * Pre-registered memory.  Buffers are allocated by iscsi from us, handed
- * to device to fill, then iser can send them directly without registration.
- * Also for write path.
- */
-struct mempool {
-	struct list_head list;
-	void *buf;
-};
-
-/*
- * Shared variables for a particular device.  The conn[] array will
- * have to be broken out when multiple device support is added, maybe with
- * a pointer into this "device" struct.
- */
-struct iser_device {
-	struct list_head list;
-	struct ibv_context *ibv_hndl;
-	struct ibv_pd *pd;
-	struct ibv_cq *cq;
-	struct ibv_comp_channel *cq_channel;
-
-	/* mempool registered buffer, list area, handle */
-	void *mempool_regbuf;
-	void *mempool_listbuf;
-	struct ibv_mr *mempool_mr;
-
-	struct event_data poll_sched;
-
-	/* free and allocated mempool entries */
-	struct list_head mempool_free, mempool_alloc;
-};
-
-static struct iscsi_transport iscsi_iser;
-
-/* global, across all devices */
-static struct rdma_event_channel *rdma_evt_channel;
-static struct rdma_cm_id *cma_listen_id;
-static struct list_head conn_tx_ready;  /* conns with tasks ready to tx */
-
-/* accepted at RDMA layer, but not yet established */
-static struct list_head temp_conn;
-
-/* all devices */
-static struct list_head iser_dev_list;
-
-/* all iser connections */
-static struct list_head iser_conn_list;
-
-/* if any task needs an rdma read or write slot to proceed */
-static int waiting_rdma_slot;
-
-#define uint64_from_ptr(p) (uint64_t)(uintptr_t)(p)
-#define ptr_from_int64(p) (void *)(unsigned long)(p)
-
-/*
- * Crazy hard-coded linux iser settings need 128 * 8 slots + slop, plus
- * room for our rdmas and send requests.
- */
-#define MAX_WQE 1800
-
-/*
- * Number of outstanding RDMAs per command; should instead wait for previous
- * RDMAs to complete before starting new ones.
- *
- * The RDMA size is completely up to the target.  Parameters IRDSL and TRDSL
- * only apply to control-type PDUs.  We allocate only so many rdma slots
- * per connection, but many tasks might be in progress on the connection.
- * Internal flow control stops tasks when there are no slots.
- *
- * RDMA size tradeoffs (MaxBurstLength):
- *    big RDMA operations are more efficient
- *    small RDMA operations better for fairness with many clients
- *    small RDMA operations allow better pipelining
- *    eventually target devices may not want to have to malloc and return
- *        entire buffer to transport in one go
- */
-#define RDMA_PER_CONN 20
-
-#define MAX_POLL_WC 8
-
-/*
- * Number of allocatable data buffers, each of this size.  Do at least 128
- * for linux iser.  The mempool size is rounded up at initialization time
- * to the hardware page size so that allocations for direct IO devices are
- * aligned.
- */
-static int mempool_num = 192;
-static size_t mempool_size = 512 * 1024;
-
-static inline struct iser_task *ISER_TASK(struct iscsi_task *t)
-{
-	return container_of(t, struct iser_task, task);
-}
-
-static inline struct conn_info *RDMA_CONN(struct iscsi_connection *conn)
-{
-	return container_of(conn, struct conn_info, iscsi_conn);
-}
-
-static void iser_cqe_handler(int fd __attribute__((unused)),
-			     int events __attribute__((unused)),
-			     void *data);
-static void iser_rdma_read_completion(struct rdmalist *rdma);
-static void iscsi_rdma_release(struct iscsi_connection *conn);
-static int iscsi_rdma_show(struct iscsi_connection *conn, char *buf,
-			   int rest);
-static void iscsi_rdma_event_modify(struct iscsi_connection *conn, int events);
-static void iser_sched_poll_cq(struct event_data *tev);
-static void iser_sched_consume_cq(struct event_data *tev);
-static void iser_sched_tx(struct event_data *evt);
-
-/*
- * Called when ready for full feature, builds resources.
- */
-static int iser_init_comm(struct conn_info *conn)
-{
-	unsigned int i;
-	int ret = -1;
-	unsigned long size;
-	uint8_t *srbuf, *listbuf;
-	struct sendlist *sendl;
-	struct recvlist *recvl;
-	struct rdmalist *rdmal;
-	struct ibv_recv_wr *bad_wr;
-	int rdma_per_conn = RDMA_PER_CONN;
-
-	dprintf("sizing %u/%u outst %u\n", conn->ssize, conn->rsize,
-		conn->max_outst_pdu);
-
-	size = (conn->rsize + conn->ssize) * conn->max_outst_pdu;
-	conn->srbuf = malloc(size);
-	if (!conn->srbuf) {
-		eprintf("malloc srbuf %lu\n", size);
-		goto out;
-	}
-
-	conn->srmr = ibv_reg_mr(conn->dev->pd, conn->srbuf, size,
-				IBV_ACCESS_LOCAL_WRITE);
-	if (!conn->srmr) {
-		eprintf("register srbuf\n");
-		goto out;
-	}
-
-	INIT_LIST_HEAD(&conn->sendl);
-	INIT_LIST_HEAD(&conn->rdmal);
-
-	size = conn->max_outst_pdu * sizeof(struct sendlist) +
-	       conn->max_outst_pdu * sizeof(struct recvlist) +
-	       conn->max_outst_pdu * rdma_per_conn * sizeof(struct rdmalist);
-	conn->listbuf = malloc(size);
-	if (!conn->listbuf) {
-		eprintf("malloc listbuf %lu\n", size);
-		goto out;
-	}
-	memset(conn->listbuf, 0, size);
-
-	srbuf = conn->srbuf;
-	listbuf = conn->listbuf;
-	for (i = 0; i < conn->max_outst_pdu; i++) {
-		sendl = (void *) listbuf;
-		listbuf += sizeof(*sendl);
-		sendl->buf = srbuf;
-		srbuf += conn->ssize;
-		sendl->conn = conn;
-
-		sendl->sge.addr = uint64_from_ptr(sendl->buf);
-		sendl->sge.length = conn->ssize;
-		sendl->sge.lkey = conn->srmr->lkey;
-
-		sendl->wr.wr_id = uint64_from_ptr(sendl);
-		sendl->wr.sg_list = &sendl->sge;
-		sendl->wr.num_sge = 1;
-		sendl->wr.opcode = IBV_WR_SEND;
-		sendl->wr.send_flags = IBV_SEND_SIGNALED;
-		list_add_tail(&sendl->list, &conn->sendl);
-	}
-
-	for (i = 0; i < conn->max_outst_pdu; i++) {
-		recvl = (void *) listbuf;
-		listbuf += sizeof(*recvl);
-		recvl->buf = srbuf;
-		srbuf += conn->rsize;
-		recvl->conn = conn;
-
-		recvl->sge.addr = uint64_from_ptr(recvl->buf);
-		recvl->sge.length = conn->rsize;
-		recvl->sge.lkey = conn->srmr->lkey;
-
-		recvl->wr.wr_id = uint64_from_ptr(recvl);
-		recvl->wr.sg_list = &recvl->sge;
-		recvl->wr.num_sge = 1;
-
-		ret = ibv_post_recv(conn->qp_hndl, &recvl->wr, &bad_wr);
-		if (ret) {
-			eprintf("ibv_post_recv (%d/%d): %m\n", i,
-				conn->max_outst_pdu);
-			exit(1);
-		}
-		++conn->recvl_posted;
-	}
-
-	for (i = 0; i < conn->max_outst_pdu * rdma_per_conn; i++) {
-		rdmal = (void *) listbuf;
-		listbuf += sizeof(*rdmal);
-		rdmal->conn = conn;
-		rdmal->sge.lkey = conn->dev->mempool_mr->lkey;
-
-		rdmal->wr.wr_id = uint64_from_ptr(rdmal);
-		rdmal->wr.sg_list = &rdmal->sge;
-		rdmal->wr.num_sge = 1;
-		rdmal->wr.send_flags = IBV_SEND_SIGNALED;
-		list_add_tail(&rdmal->list, &conn->rdmal);
-	}
-
-	ret = 0;
-
-out:
-	return ret;
-}
-
-/*
- * Called at accept time, builds resources just for login phase.
- */
-static int iser_init_comm_login(struct conn_info *conn)
-{
-	unsigned int i;
-	int ret = -1;
-	unsigned long size;
-	uint8_t *srbuf, *listbuf;
-	struct sendlist *sendl;
-	struct recvlist *recvl;
-	struct ibv_recv_wr *bad_wr;
-
-	dprintf("sizing %u/%u outst %u\n", conn->ssize, conn->rsize,
-		conn->max_outst_pdu);
-
-	size = (conn->rsize + conn->ssize) * conn->max_outst_pdu;
-	conn->srbuf_login = malloc(size);
-	if (!conn->srbuf_login) {
-		eprintf("malloc srbuf %lu\n", size);
-		goto out;
-	}
-
-	conn->srmr_login = ibv_reg_mr(conn->dev->pd, conn->srbuf_login, size,
-				      IBV_ACCESS_LOCAL_WRITE);
-	if (!conn->srmr_login) {
-		eprintf("ibv_reg_mr srbuf failed\n");
-		goto out;
-	}
-
-	INIT_LIST_HEAD(&conn->sendl_login);
-	INIT_LIST_HEAD(&conn->recvl_login);
-
-	size = conn->max_outst_pdu * sizeof(struct sendlist) +
-	       conn->max_outst_pdu * sizeof(struct recvlist);
-	conn->listbuf_login = malloc(size);
-	if (!conn->listbuf_login) {
-		eprintf("malloc listbuf %lu\n", size);
-		goto out;
-	}
-	memset(conn->listbuf_login, 0, size);
-
-	srbuf = conn->srbuf_login;
-	listbuf = conn->listbuf_login;
-	for (i = 0; i < conn->max_outst_pdu; i++) {
-		sendl = (void *) listbuf;
-		listbuf += sizeof(*sendl);
-		sendl->buf = srbuf;
-		srbuf += conn->ssize;
-		sendl->conn = conn;
-
-		sendl->sge.addr = uint64_from_ptr(sendl->buf);
-		sendl->sge.length = conn->ssize;
-		sendl->sge.lkey = conn->srmr_login->lkey;
-
-		sendl->wr.wr_id = uint64_from_ptr(sendl);
-		sendl->wr.sg_list = &sendl->sge;
-		sendl->wr.num_sge = 1;
-		sendl->wr.opcode = IBV_WR_SEND;
-		sendl->wr.send_flags = IBV_SEND_SIGNALED;
-		list_add_tail(&sendl->list, &conn->sendl_login);
-	}
-
-	for (i = 0; i < conn->max_outst_pdu; i++) {
-		recvl = (void *) listbuf;
-		listbuf += sizeof(*recvl);
-		recvl->buf = srbuf;
-		srbuf += conn->rsize;
-		recvl->conn = conn;
-
-		recvl->sge.addr = uint64_from_ptr(recvl->buf);
-		recvl->sge.length = conn->rsize;
-		recvl->sge.lkey = conn->srmr_login->lkey;
-
-		recvl->wr.wr_id = uint64_from_ptr(recvl);
-		recvl->wr.sg_list = &recvl->sge;
-		recvl->wr.num_sge = 1;
-		recvl->wr.next = NULL;
-
-		ret = ibv_post_recv(conn->qp_hndl, &recvl->wr, &bad_wr);
-		if (ret) {
-			eprintf("ibv_post_recv: %m\n");
-			goto out;
-		}
-	}
-
-	ret = 0;
-
-out:
-	return ret;
-}
-
-/*
- * On connection shutdown.
- */
-static void iser_free_comm(struct conn_info *ci)
-{
-	int ret;
-
-	dprintf("freeing conn %p\n", ci);
-
-	/* release mr and free the lists */
-	dprintf("dereg mr %p\n", ci->srmr);
-	ret = ibv_dereg_mr(ci->srmr);
-	if (ret)
-		eprintf("ibv_dereg_mr\n");
-	free(ci->srbuf);
-	free(ci->listbuf);
-}
-
-/*
- * When ready for full-feature mode, free login-phase resources.
- */
-static void iser_free_comm_login(struct conn_info *ci)
-{
-	int ret;
-
-	if (ci->srbuf_login == NULL)
-		return;
-
-	dprintf("freeing, login phase %d\n", ci->login_phase);
-
-	/* release mr and free the lists */
-	ret = ibv_dereg_mr(ci->srmr_login);
-	if (ret)
-		eprintf("ibv_dereg_mr\n");
-	free(ci->srbuf_login);
-	free(ci->listbuf_login);
-	ci->srbuf_login = NULL;  /* remember freed */
-}
-
-/*
- * One pool of registered memory per device (per PD that is).
- */
-static int iser_init_mempool(struct iser_device *dev)
-{
-	struct mempool *mp;
-	uint8_t *regbuf, *listbuf;
-	int i;
-
-	mempool_size = roundup(mempool_size, pagesize);
-	regbuf = valloc(mempool_num * mempool_size);
-	if (!regbuf) {
-		eprintf("malloc regbuf %zu\n", mempool_num * mempool_size);
-		return -ENOMEM;
-	}
-
-	listbuf = malloc(mempool_num * sizeof(*mp));
-	if (!listbuf) {
-		eprintf("malloc listbuf %zu\n", mempool_num * sizeof(*mp));
-		free(regbuf);
-		return -ENOMEM;
-	}
-
-	dev->mempool_mr = ibv_reg_mr(dev->pd, regbuf,
-				     mempool_num * mempool_size,
-				     IBV_ACCESS_LOCAL_WRITE);
-	if (!dev->mempool_mr) {
-		eprintf("register regbuf\n");
-		free(regbuf);
-		free(listbuf);
-		return -1;
-	}
-
-	dev->mempool_regbuf = regbuf;
-	dev->mempool_listbuf = listbuf;
-	INIT_LIST_HEAD(&dev->mempool_free);
-	INIT_LIST_HEAD(&dev->mempool_alloc);
-
-	for (i = 0; i < mempool_num; i++) {
-		mp = (void *) listbuf;
-		listbuf += sizeof(*mp);
-		mp->buf = regbuf;
-		regbuf += mempool_size;
-		list_add_tail(&mp->list, &dev->mempool_free);
-	}
-
-	return 0;
-}
-
-/*
- * First time a new connection is received on an RDMA device, record
- * it and build a PD and static memory.
- */
-static int iser_device_init(struct iser_device *dev)
-{
-	struct ibv_device_attr device_attr;
-	int cqe_num;
-	int ret = -1;
-
-	dprintf("dev %p\n", dev);
-	dev->pd = ibv_alloc_pd(dev->ibv_hndl);
-	if (dev->pd == NULL) {
-		eprintf("ibv_alloc_pd failed\n");
-		goto out;
-	}
-
-	ret = iser_init_mempool(dev);
-	if (ret) {
-		eprintf("iser_init_mempool failed\n");
-		goto out;
-	}
-
-	ret = ibv_query_device(dev->ibv_hndl, &device_attr);
-	if (ret < 0) {
-		eprintf("ibv_query_device: %m\n");
-		goto out;
-	}
-	cqe_num = device_attr.max_cqe;
-	dprintf("max %d CQEs\n", cqe_num);
-
-	ret = -1;
-	dev->cq_channel = ibv_create_comp_channel(dev->ibv_hndl);
-	if (dev->cq_channel == NULL) {
-		eprintf("ibv_create_comp_channel failed: %m\n");
-		goto out;
-	}
-
-	dev->cq = ibv_create_cq(dev->ibv_hndl, cqe_num, NULL,
-				dev->cq_channel, 0);
-	if (dev->cq == NULL) {
-		eprintf("ibv_create_cq failed: %m\n");
-		goto out;
-	}
-
-	tgt_init_sched_event(&dev->poll_sched, iser_sched_poll_cq, dev);
-
-	ret = ibv_req_notify_cq(dev->cq, 0);
-	if (ret) {
-		eprintf("ibv_req_notify failed: %s\n", strerror(ret));
-		goto out;
-	}
-
-	ret = tgt_event_add(dev->cq_channel->fd, EPOLLIN, iser_cqe_handler,
-			    dev);
-	if (ret) {
-		eprintf("tgt_event_add failed: %m\n");
-		goto out;
-
-	}
-
-	list_add(&dev->list, &iser_dev_list);
-
-out:
-	return ret;
-}
-
-static void iser_accept_connection(struct rdma_cm_event *event)
-{
-	int ret, found;
-	struct ibv_qp_init_attr qp_init_attr;
-	struct iscsi_connection *conn;
-	struct conn_info *ci;
-	struct iser_device *dev;
-	unsigned int hdrsz;
-	struct rdma_conn_param conn_param = {
-		.responder_resources = 1,
-		.initiator_depth = 1,
-		.retry_count = 5,
-	};
-
-	dprintf("entry\n");
-
-	/* find device */
-	found = 0;
-	list_for_each_entry(dev, &iser_dev_list, list) {
-		if (dev->ibv_hndl == event->id->verbs) {
-			found = 1;
-			break;
-		}
-	}
-	if (!found) {
-		dev = malloc(sizeof(*dev));
-		if (dev == NULL) {
-			eprintf("unable to allocate dev\n");
-			goto reject;
-		}
-		dev->ibv_hndl = event->id->verbs;
-		ret = iser_device_init(dev);
-		if (ret) {
-			free(dev);
-			goto reject;
-		}
-	}
-
-	/* build a new connection structure */
-	ci = zalloc(sizeof(*ci));
-	if (!ci) {
-		eprintf("unable to allocate conn\n");
-		goto reject;
-	}
-	conn = &ci->iscsi_conn;
-
-	ret = conn_init(conn);
-	if (ret) {
-		free(ci);
-		goto reject;
-	}
-
-	conn->tp = &iscsi_iser;
-	conn_read_pdu(conn);
-	ci->cma_id = event->id;
-	ci->dev = dev;
-	ci->login_phase = LOGIN_PHASE_START;
-	INIT_LIST_HEAD(&ci->conn_tx_ready);
-	list_add(&ci->iser_conn_list, &temp_conn);
-
-	tgt_init_sched_event(&ci->tx_sched, iser_sched_tx, ci);
-
-	/* initiator sits at dst, we are src */
-	memcpy(&ci->peer_addr, &event->id->route.addr.dst_addr,
-	       sizeof(ci->peer_addr));
-	memcpy(&ci->self_addr, &event->id->route.addr.src_addr,
-	       sizeof(ci->self_addr));
-#ifndef NDEBUG
-	{
-		char str[256];
-
-		iscsi_rdma_show(conn, str, sizeof(str));
-		str[sizeof(str)-1] = 0;
-		dprintf("new conn %p from %s\n", ci, str);
-	}
-#endif
-
-	/* create qp next */
-	memset(&qp_init_attr, 0, sizeof(qp_init_attr));
-	/* wire both send and recv to the same CQ */
-	qp_init_attr.send_cq =  dev->cq;
-	qp_init_attr.recv_cq  = dev->cq;
-	qp_init_attr.cap.max_send_wr = MAX_WQE;
-	qp_init_attr.cap.max_recv_wr = MAX_WQE;
-	qp_init_attr.cap.max_send_sge = 1;  /* scatter/gather entries */
-	qp_init_attr.cap.max_recv_sge = 1;
-	qp_init_attr.qp_type = IBV_QPT_RC;
-	/* only generate completion queue entries if requested */
-	qp_init_attr.sq_sig_all = 0;
-
-	ret = rdma_create_qp(ci->cma_id, dev->pd, &qp_init_attr);
-	if (ret) {
-		eprintf("create qp failed\n");
-		goto free_conn;
-	}
-	ci->qp_hndl = ci->cma_id->qp;
-	VALGRIND_MAKE_MEM_DEFINED(ci->qp_hndl, sizeof(*ci->qp_hndl));
-
-	ci->rcv_comm_event = NULL;
-	ci->send_comm_event = NULL;
-	ci->readb = 0;
-	ci->writeb = 0;
-
-	/*
-	 * Post buffers for the login phase, only.
-	 */
-	hdrsz = sizeof(struct iser_hdr) +
-		sizeof(struct iscsi_hdr) +
-		sizeof(struct iscsi_ecdb_ahdr) +
-		sizeof(struct iscsi_rlength_ahdr);
-	ci->ssize = hdrsz + 8192;
-	ci->rsize = hdrsz + 8192;
-	ci->max_outst_pdu = 1;
-	ret = iser_init_comm_login(ci);
-	if (ret) {
-		iser_free_comm_login(ci);
-		goto free_conn;
-	}
-
-	/* now we can actually accept the connection */
-	ret = rdma_accept(ci->cma_id, &conn_param);
-	if (ret) {
-		eprintf("rdma_accept failed\n");
-		iser_free_comm_login(ci);
-		goto free_conn;
-	}
-
-	return;
-
-free_conn:
-	conn_exit(conn);
-	free(ci);
-reject:
-	ret = rdma_reject(event->id, NULL, 0);
-	if (ret)
-		eprintf("rdma_reject failed: %s\n", strerror(-ret));
-}
-
-/*
- * Finish putting the connection together, now that the other side
- * has ACKed our acceptance.  Moves it from the temp_conn to the
- * iser_conn_list.
- *
- * Release the temporary conn_info and glue it into iser_conn_list.
- */
-static void iser_conn_established(struct rdma_cm_event *event)
-{
-	int found = 0;
-	struct conn_info *ci;
-
-	/* find it in connection list */
-	list_for_each_entry(ci, &temp_conn, iser_conn_list) {
-		if (ci->cma_id == event->id) {
-			found = 1;
-			break;
-		}
-	}
-	if (!found) {
-		eprintf("cma id %p not found\n", event->id);
-		return;
-	}
-	dprintf("established conn %p\n", ci);
-	list_del(&ci->iser_conn_list);
-	list_add(&ci->iser_conn_list, &iser_conn_list);
-}
-
-static void iser_disconnect(struct rdma_cm_event *ev)
-{
-	struct conn_info *ci;
-
-	/*
-	 * If not found, initiator disconnected first, so tell iscsi about
-	 * it; else iscsi already did the conn_close.
-	 */
-	dprintf("initiator disconn, QP %d\n", ev->id->qp->qp_num);
-	list_for_each_entry(ci, &iser_conn_list, iser_conn_list) {
-		if (ci->qp_hndl->qp_num == ev->id->qp->qp_num) {
-			struct iscsi_connection *conn = &ci->iscsi_conn;
-			conn->state = STATE_CLOSE;
-			conn_close(conn);
-			break;
-		}
-	}
-}
-
-/*
- * Handle RDMA connection events.
- */
-static void iser_handle_rdmacm(int fd __attribute__((unused)),
-			       int events __attribute__((unused)),
-			       void *data __attribute__((unused)))
-{
-	int ret;
-	struct rdma_cm_event *event;
-	struct rdma_cm_id *destroy_cm_id = NULL;
-
-	dprintf("entry\n");
-	ret = rdma_get_cm_event(rdma_evt_channel, &event);
-	if (ret) {
-		eprintf("rdma_get_cm_event failed\n");
-		return;
-	}
-
-	VALGRIND_MAKE_MEM_DEFINED(event, sizeof(*event));
-	switch (event->event) {
-	case RDMA_CM_EVENT_CONNECT_REQUEST:
-		iser_accept_connection(event);
-		break;
-	case RDMA_CM_EVENT_ESTABLISHED:
-		iser_conn_established(event);
-		break;
-	case RDMA_CM_EVENT_DISCONNECTED:
-		iser_disconnect(event);
-		destroy_cm_id = event->id;
-		break;
-	default:
-		eprintf("unknown event %d\n", event->event);
-		break;
-	}
-
-	ret = rdma_ack_cm_event(event);
-	if (ret) {
-		eprintf("ack cm event failed\n");
-		return;
-	}
-
-	if (destroy_cm_id) {
-		ret = rdma_destroy_id(destroy_cm_id);
-		if (ret)
-			eprintf("rdma_destroy_id failed\n");
-	}
-}
-
-/*
- * Deal with just one work completion.
- */
-static void handle_wc(struct ibv_wc *wc)
-{
-	int ret;
-	struct recvlist *recvl;
-	struct sendlist *sendl;
-	struct rdmalist *rdmal;
-	struct conn_info *ci;
-	struct iscsi_connection *conn;
-	struct ibv_recv_wr *bad_wr;
-
-	switch (wc->opcode) {
-	case IBV_WC_SEND:
-		dprintf("outgoing rsp complete\n");
-		sendl = ptr_from_int64(wc->wr_id);
-		ci = sendl->conn;
-		if (ci->login_phase == LOGIN_PHASE_START) {
-		    list_add(&sendl->list, &ci->sendl_login);
-		} else if (ci->login_phase == LOGIN_PHASE_LAST_SEND) {
-			/* release login resources */
-			dprintf("last login send completed, release, to ff\n");
-			iser_free_comm_login(ci);
-			ci->login_phase = LOGIN_PHASE_FF;
-			break;
-		} else {
-		    list_add(&sendl->list, &ci->sendl);
-		}
-		break;
-
-	case IBV_WC_RECV:
-		dprintf("incoming cmd, len %d\n", wc->byte_len);
-		recvl = ptr_from_int64(wc->wr_id);
-		ci = recvl->conn;
-		conn = &ci->iscsi_conn;
-		--ci->recvl_posted;
-		if (conn->state == STATE_CLOSE)
-			goto close_err;
-
-		recvl->bytes_recvd = wc->byte_len;
-		VALGRIND_MAKE_MEM_DEFINED(recvl->buf, recvl->bytes_recvd);
-
-		/*
-		 * Global pointer to the working receive on this connection
-		 * for reads from iscsid.c.
-		 */
-		ci->rcv_comm_event = recvl;
-		iscsi_rx_handler(conn);
-		ci->rcv_comm_event = NULL;
-
-		if (ci->login_phase == LOGIN_PHASE_LAST_SEND) {
-			/* do not repost, just one more send then reinit */
-			dprintf("transitioning to full-feature, no repost\n");
-			break;
-		}
-
-		dprintf("incoming cmd proc done, repost\n");
-		ret = ibv_post_recv(ci->qp_hndl, &recvl->wr, &bad_wr);
-		if (ret) {
-			eprintf("ibv_post_recv failed\n");
-			exit(1);
-		}
-		++ci->recvl_posted;
-		break;
-
-	case IBV_WC_RDMA_WRITE:
-		dprintf("RDMA write done\n");
-		rdmal = ptr_from_int64(wc->wr_id);
-		ci = rdmal->conn;
-		conn = &ci->iscsi_conn;
-		if (conn->state == STATE_CLOSE)
-			goto close_err;
-
-		iscsi_rdma_event_modify(conn, EPOLLIN | EPOLLOUT);
-		list_add(&rdmal->list, &ci->rdmal);
-		if (waiting_rdma_slot) {
-			waiting_rdma_slot = 0;
-			tgt_add_sched_event(&ci->tx_sched);
-		}
-		break;
-
-	case IBV_WC_RDMA_READ:
-		dprintf("RDMA read done, len %d\n", wc->byte_len);
-		rdmal = ptr_from_int64(wc->wr_id);
-		ci = rdmal->conn;
-		conn = &ci->iscsi_conn;
-		if (conn->state == STATE_CLOSE)
-			goto close_err;
-
-		assert(rdmal->sge.length == wc->byte_len);
-		iser_rdma_read_completion(rdmal);
-		list_add(&rdmal->list, &ci->rdmal);
-		if (waiting_rdma_slot) {
-			waiting_rdma_slot = 0;
-			tgt_add_sched_event(&ci->tx_sched);
-		}
-		break;
-
-	default:
-		eprintf("unexpected opcode %d\n", wc->opcode);
-		exit(1);
-	}
-
-	return;
-
-close_err:
-	eprintf("conn state set to closed .. IMPLEMENT ME\n");
-	exit(1);
-}
-
-/*
- * Could read as many entries as possible without blocking, but
- * that just fills up a list of tasks.  Instead pop out of here
- * so that tx progress, like issuing rdma reads and writes, can
- * happen periodically.
- */
-static int iser_poll_cq(struct iser_device *dev, int max_wc)
-{
-	int ret = 0, numwc = 0;
-	struct ibv_wc wc;
-	struct conn_info *ci;
-	struct recvlist *recvl;
-
-	for (;;) {
-		ret = ibv_poll_cq(dev->cq, 1, &wc);
-		if (ret < 0) {
-			eprintf("ibv_poll_cq %d\n", ret);
-			break;
-		} else if (ret == 0) {
-			break;
-		}
-
-		VALGRIND_MAKE_MEM_DEFINED(&wc, sizeof(wc));
-		if (wc.status == IBV_WC_SUCCESS) {
-			handle_wc(&wc);
-			if (++numwc == max_wc) {
-				ret = 1;
-				break;
-			}
-		} else if (wc.status == IBV_WC_WR_FLUSH_ERR) {
-			recvl = ptr_from_int64(wc.wr_id);
-			ci = recvl->conn;
-			if (ci->draining) {
-				--ci->recvl_posted;
-				if (ci->freed && ci->recvl_posted == 0)
-					iscsi_rdma_release(&ci->iscsi_conn);
-			} else {
-				eprintf("conn %p wr flush err\n", ci);
-				/* call disconnect now? */
-			}
-		} else {
-			eprintf("bad WC status %d for wr_id 0x%llx\n",
-				wc.status, (unsigned long long) wc.wr_id);
-		}
-	}
-	return ret;
-}
-
-static void iser_poll_cq_armable(struct iser_device *dev)
-{
-	int ret;
-
-	ret = iser_poll_cq(dev, MAX_POLL_WC);
-	if (ret < 0)
-		exit(1);
-
-	if (ret == 0) {
-		/* no more completions on cq, arm the completion interrupts */
-		ret = ibv_req_notify_cq(dev->cq, 0);
-		if (ret) {
-			eprintf("ibv_req_notify_cq: %s\n", strerror(ret));
-			exit(1);
-		}
-		dev->poll_sched.sched_handler = iser_sched_consume_cq;
-	} else
-		dev->poll_sched.sched_handler = iser_sched_poll_cq;
-
-	tgt_add_sched_event(&dev->poll_sched);
-}
-
-/* Scheduled to poll cq after a completion event has been
-   received and acknowledged, if no more completions are found
-   the interrupts are re-armed */
-static void iser_sched_poll_cq(struct event_data *tev)
-{
-	struct iser_device *dev = tev->data;
-	iser_poll_cq_armable(dev);
-}
-
-/* Scheduled to consume completion events that could arrive
-   after the cq had been seen empty but just before
-   the notification interrupts were re-armed.
-   Intended to consume those remaining completions only,
-   this function does not re-arm interrupts. */
-static void iser_sched_consume_cq(struct event_data *tev)
-{
-	struct iser_device *dev = tev->data;
-	int ret;
-
-	ret = iser_poll_cq(dev, MAX_POLL_WC);
-	if (ret < 0)
-		exit(1);
-}
-
-/*
- * Called directly from main event loop when a CQ notification is
- * available.
- */
-static void iser_cqe_handler(int fd __attribute__((unused)),
-			     int events __attribute__((unused)),
-			     void *data)
-{
-	struct iser_device *dev = data;
-	void *cq_context;
-	int ret;
-
-	ret = ibv_get_cq_event(dev->cq_channel, &dev->cq, &cq_context);
-	if (ret != 0) {
-		eprintf("notification, but no CQ event\n");
-		exit(1);
-	}
-
-	ibv_ack_cq_events(dev->cq, 1);
-
-	/* if a poll was previosuly scheduled, remove it,
-	   as it will be scheduled when necessary */
-	if (dev->poll_sched.scheduled)
-		tgt_remove_sched_event(&dev->poll_sched);
-
-	iser_poll_cq_armable(dev);
-}
-
-/*
- * Called from tgtd as a scheduled event
- * tries to push tx on a connection, until nothing
- * is ready anymore.  No progress limit here.
- */
-static void iser_sched_tx(struct event_data *evt)
-{
-	struct conn_info *ci = evt->data;
-	struct iscsi_connection *conn = &ci->iscsi_conn;
-	int ret;
-
-	dprintf("entry\n");
-
-	if (conn->state == STATE_CLOSE) {
-		dprintf("ignoring tx for closed conn\n");
-		return;
-	}
-
-	for (;;) {
-		dprintf("trying tx\n");
-		ret = iscsi_tx_handler(conn);
-		if (conn->state == STATE_CLOSE) {
-			conn_close(conn);
-			dprintf("connection %p closed\n", ci);
-			break;
-		}
-		if (ret != 0) {
-			/* but leave on tx ready list */
-			waiting_rdma_slot = 1;
-			break;
-		}
-	}
-}
-
-/*
- * Init entire iscsi transport.  Begin listening for connections.
- */
-static int iscsi_rdma_init(void)
-{
-	int ret;
-	struct sockaddr_in sock_addr;
-	short int port = iscsi_listen_port;
-
-	rdma_evt_channel = rdma_create_event_channel();
-
-	if (!rdma_evt_channel) {
-		eprintf("cannot initialize RDMA; load kernel modules?\n");
-		return -1;
-	}
-
-	ret = rdma_create_id(rdma_evt_channel, &cma_listen_id, NULL,
-			     RDMA_PS_TCP);
-	if (ret) {
-		eprintf("rdma_create_id: %s\n", strerror(ret));
-		return -1;
-	}
-
-	memset(&sock_addr, 0, sizeof(sock_addr));
-	sock_addr.sin_family = AF_INET;
-	sock_addr.sin_port = htons(port);
-	sock_addr.sin_addr.s_addr = INADDR_ANY;
-	ret = rdma_bind_addr(cma_listen_id, (struct sockaddr *) &sock_addr);
-	if (ret) {
-		if (ret == -1)
-			eprintf("rdma_bind_addr -1: %m\n");
-		else
-			eprintf("rdma_bind_addr: %s\n", strerror(-ret));
-		return -1;
-	}
-
-	/* 0 == maximum backlog */
-	ret = rdma_listen(cma_listen_id, 0);
-	if (ret) {
-		if (ret == -1)
-			eprintf("rdma_listen -1: %m\n");
-		else
-			eprintf("rdma_listen: %s\n", strerror(-ret));
-		return -1;
-	}
-
-	dprintf("listening for iser connections on port %d\n", port);
-	ret = tgt_event_add(cma_listen_id->channel->fd, EPOLLIN,
-			    iser_handle_rdmacm, NULL);
-	if (ret)
-		return ret;
-
-	INIT_LIST_HEAD(&conn_tx_ready);
-	INIT_LIST_HEAD(&iser_dev_list);
-	INIT_LIST_HEAD(&iser_conn_list);
-	INIT_LIST_HEAD(&temp_conn);
-
-	return ret;
-}
-
-/*
- * Allocate resources for this new connection.  Called after login, when
- * final negotiated transfer parameters are known.
- */
-static int iscsi_rdma_login_complete(struct iscsi_connection *conn)
-{
-	int ret = -1;
-	struct conn_info *ci = RDMA_CONN(conn);
-	unsigned int irdsl, trdsl, outst_pdu, hdrsz;
-
-	dprintf("entry\n");
-
-	/*
-	 * Build full feature connection structures, but leave around the
-	 * login ones until the final send finishes.
-	 */
-	ci->login_phase = LOGIN_PHASE_LAST_SEND;  /* one more send, then done */
-	irdsl = conn->session_param[ISCSI_PARAM_INITIATOR_RDSL].val;
-	trdsl = conn->session_param[ISCSI_PARAM_TARGET_RDSL].val;
-	outst_pdu = conn->session_param[ISCSI_PARAM_MAX_OUTST_PDU].val;
-
-	/* hack, ib/ulp/iser does not have this param, but reading the code
-	 * shows
-	 *    ISCSI_XMIT_CMDS_MAX=128
-	 *    ISER_INFLIGHT_DATAOUTS=8
-	 *    ISER_MAX_RX_MISC_PDUS=4
-	 *    ISER_MAX_TX_MISC_PDUS=6
-	 * and their formula for max tx dtos outstanding
-	 *    = cmds_max * (1 + dataouts) + rx_misc + tx_misc
-	 */
-	if (outst_pdu == 0)
-		outst_pdu = 128 * (1 + 8) + 6 + 4;
-
-	/* RDSLs do not include headers. */
-	hdrsz = sizeof(struct iser_hdr) +
-		sizeof(struct iscsi_hdr) +
-		sizeof(struct iscsi_ecdb_ahdr) +
-		sizeof(struct iscsi_rlength_ahdr);
-
-	ci->ssize = hdrsz + irdsl;
-	ci->rsize = hdrsz + trdsl;
-	ci->max_outst_pdu = outst_pdu;
-	ret = iser_init_comm(ci);
-	if (ret)
-		eprintf("iser_init_comm failed\n");
-
-	return ret;
-}
-
-/*
- * Copy the remote va and stag that were temporarily saved in conn_info.
- */
-static struct iscsi_task *iscsi_iser_alloc_task(struct iscsi_connection *conn,
-						size_t ext_len)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct iser_task *itask;
-
-	itask = zalloc(sizeof(*itask) + ext_len);
-	if (!itask)
-		return NULL;
-
-	itask->rem_read_stag = ci->rem_read_stag;
-	itask->rem_read_va = ci->rem_read_va;
-	itask->rem_write_stag = ci->rem_write_stag;
-	itask->rem_write_va = ci->rem_write_va;
-
-	return &itask->task;
-}
-
-static void iscsi_iser_free_task(struct iscsi_task *task)
-{
-	free(ISER_TASK(task));
-}
-
-static int iser_parse_hdr(struct conn_info *ci, struct recvlist *recvl)
-{
-	int ret = -1;
-	struct iser_hdr *hdr = recvl->buf;
-
-	switch (hdr->flags & 0xF0) {
-	case ISCSI_CTRL:
-		dprintf("control type PDU\n");
-		if (hdr->flags & ISER_RSV) {
-			ci->rem_read_stag = be32_to_cpu(hdr->read_stag);
-			ci->rem_read_va = be64_to_cpu(hdr->read_va);
-			dprintf("rstag %x va %llx\n",
-				ci->rem_read_stag,
-				(unsigned long long) ci->rem_read_va);
-		}
-		if (hdr->flags & ISER_WSV) {
-			ci->rem_write_stag = be32_to_cpu(hdr->write_stag);
-			ci->rem_write_va = be64_to_cpu(hdr->write_va);
-			dprintf("wstag %x va %llx\n",
-				ci->rem_write_stag,
-				(unsigned long long) ci->rem_write_va);
-		}
-		ret = 0;
-		break;
-	case ISER_HELLO:
-		dprintf("iSER Hello message??\n");
-		break;
-	default:
-		eprintf("malformed iser hdr, flags 0x%02x\n", hdr->flags);
-		break;
-	}
-
-	ci->readb = sizeof(*hdr);
-	return ret;
-}
-
-static size_t iscsi_iser_read(struct iscsi_connection *conn, void *buf,
-			      size_t nbytes)
-{
-	int ret;
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct recvlist *recvl;
-
-	dprintf("buf %p nbytes %zu\n", buf, nbytes);
-	recvl = ci->rcv_comm_event;
-	assert(recvl != NULL);
-
-	if (ci->readb == 0) {
-		if (recvl->bytes_recvd < sizeof(struct iser_hdr))
-			return 0;
-
-		ret = iser_parse_hdr(ci, recvl);
-		if (ret != 0)
-			return 0;
-	}
-
-	if (ci->readb + nbytes > recvl->bytes_recvd) {
-		if (ci->readb > recvl->bytes_recvd)
-			nbytes = recvl->bytes_recvd;
-		else
-			nbytes = recvl->bytes_recvd - ci->readb;
-	}
-
-	/* always copy headers into iscsi task structure */
-	memcpy(buf, (char *) recvl->buf + ci->readb, nbytes);
-	ci->readb += nbytes;
-
-	if (ci->readb == recvl->bytes_recvd)
-		ci->readb = 0;
-
-	return nbytes;
-}
-
-static size_t iscsi_iser_write_begin(struct iscsi_connection *conn,
-				     void *buf, size_t nbytes)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct sendlist *sendl;
-
-	if (ci->send_comm_event == NULL) {
-		/* find one, first time here */
-		struct list_head *ci_sendl = &ci->sendl;
-
-		if (ci->login_phase != LOGIN_PHASE_FF)
-			ci_sendl = &ci->sendl_login;
-
-		if (list_empty(ci_sendl)) {
-			/* bug, max outst pdu should constrain this */
-			eprintf("no free send slot\n");
-			exit(1);
-		}
-		sendl = list_entry(ci_sendl->next, typeof(*sendl), list);
-		list_del(&sendl->list);
-		ci->send_comm_event = sendl;
-		dprintf("new sendl %p len %zu\n", sendl, nbytes);
-	} else {
-		sendl = ci->send_comm_event;
-		dprintf("reuse sendl %p len %u + %zu\n", sendl, ci->writeb,
-			nbytes);
-	}
-
-	if (ci->writeb + nbytes > ci->ssize) {
-		eprintf("send buf overflow %d + %zd > %u\n", ci->writeb,
-			nbytes, ci->ssize);
-		exit(1);
-	}
-
-	if (ci->writeb == 0) {
-		/* insert iser hdr */
-		struct iser_hdr *hdr = sendl->buf;
-
-		memset(hdr, 0, sizeof(*hdr));
-		hdr->flags = ISCSI_CTRL;
-		ci->writeb = sizeof(*hdr);
-	}
-
-	memcpy((char *) sendl->buf + ci->writeb, buf, nbytes);
-	ci->writeb += nbytes;
-	return nbytes;
-}
-
-static void iscsi_iser_write_end(struct iscsi_connection *conn)
-{
-	int ret;
-	struct ibv_send_wr *bad_wr;
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct sendlist *sendl;
-
-	sendl = ci->send_comm_event;  /* set from _write_begin above */
-	dprintf("sendl %p len %d\n", sendl, ci->writeb);
-
-	sendl->sge.length = ci->writeb;
-
-	ret = ibv_post_send(ci->qp_hndl, &sendl->wr, &bad_wr);
-	if (ret) {
-		/* bug, should have sized max_outst_pdu properly */
-		eprintf("ibv_post_send ret %d\n", ret);
-		exit(1);
-	}
-
-	ci->writeb = 0;  /* reset count */
-	ci->send_comm_event = NULL;
-}
-
-/*
- * Expected opcodes are: IBV_WR_RDMA_WRITE, IBV_WR_RDMA_READ.
- */
-static int iser_post_rdma_wr(struct conn_info *ci, struct iscsi_task *task,
-			     void *buf, ssize_t size, int op,
-			     uint64_t remote_va, uint32_t remote_rkey)
-{
-	int ret;
-	struct rdmalist *rdmal;
-	struct ibv_send_wr *bad_wr;
-
-	if (list_empty(&ci->rdmal)) {
-		eprintf("no slot\n");
-		return -1;
-	}
-	rdmal = list_entry(ci->rdmal.next, typeof(*rdmal), list);
-	list_del(&rdmal->list);
-
-	rdmal->task = task;
-	rdmal->sge.addr = uint64_from_ptr(buf);
-	rdmal->sge.length = size;
-
-	rdmal->wr.opcode = op;
-	rdmal->wr.wr.rdma.remote_addr = remote_va;
-	rdmal->wr.wr.rdma.rkey = remote_rkey;
-
-	ret = ibv_post_send(ci->qp_hndl, &rdmal->wr, &bad_wr);
-	if (ret)
-		eprintf("ibv_post_send ret %d\n", ret);
-
-	return ret;
-}
-
-/*
- * Convert the iscsi r2t request to an RDMA read and post it.
- */
-static int iscsi_rdma_rdma_read(struct iscsi_connection *conn)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct iscsi_task *task = conn->tx_task;
-	struct iser_task *itask = ISER_TASK(task);
-	struct iscsi_r2t_rsp *r2t = (struct iscsi_r2t_rsp *) &conn->rsp.bhs;
-	uint8_t *buf;
-	uint32_t len;
-	int ret;
-
-	buf = (uint8_t *) task->data + task->offset;
-	len = be32_to_cpu(r2t->data_length);
-
-	dprintf("len %u stag %x va %llx\n",
-		len, itask->rem_write_stag,
-		(unsigned long long) itask->rem_write_va);
-
-	ret = iser_post_rdma_wr(ci, task, buf, len, IBV_WR_RDMA_READ,
-				itask->rem_write_va, itask->rem_write_stag);
-	if (ret < 0)
-		return ret;
-
-	/*
-	 * Initiator registers the entire buffer, but gives us a VA that
-	 * is advanced by immediate + unsolicited data amounts.  Advance
-	 * rem_va as we read, knowing that the target always grabs segments
-	 * in order.
-	 */
-	itask->rem_write_va += len;
-
-	return 0;
-}
-
-/*
- * Convert the iscsi data-in response to an RDMA write and send it.
- */
-static int iscsi_rdma_rdma_write(struct iscsi_connection *conn)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct iscsi_task *task = conn->tx_task;
-	struct iser_task *itask = ISER_TASK(task);
-	struct iscsi_pdu *rsp = &conn->rsp;
-	struct iscsi_data_rsp *datain = (struct iscsi_data_rsp *) &rsp->bhs;
-	uint32_t offset;
-	int ret;
-
-	offset = be32_to_cpu(datain->offset);
-
-	dprintf("offset %d len %d stag %x va %llx\n", offset, rsp->datasize,
-		itask->rem_read_stag, (unsigned long long) itask->rem_read_va);
-
-	ret = iser_post_rdma_wr(ci, task, rsp->data, rsp->datasize,
-				IBV_WR_RDMA_WRITE, itask->rem_read_va + offset,
-				itask->rem_read_stag);
-	if (ret < 0)
-		return ret;
-
-	/*
-	 * iscsi thinks we are txing, but really we're waiting for this
-	 * rdma to finish before sending the completion.  Then we'll stick
-	 * ourselves back on the list.
-	 */
-	if (task->offset == task->len) {
-		iscsi_rdma_event_modify(conn, EPOLLIN);
-	} else {
-		/* poke ourselves to do the next rdma */
-		tgt_add_sched_event(&ci->tx_sched);
-	}
-
-	return ret;
-}
-
-/*
- * Called from CQ processing.  Hands completed write data to iscsi.
- */
-static void iser_rdma_read_completion(struct rdmalist *rdmal)
-{
-	struct conn_info *ci = rdmal->conn;
-	struct iscsi_connection *conn = &ci->iscsi_conn;
-	struct iscsi_task *task;
-
-	/* task is no longer conn->tx_task, look it up */
-	list_for_each_entry(task, &conn->session->cmd_list, c_hlist) {
-		if (task == rdmal->task)
-			goto found;
-	}
-	eprintf("no task\n");
-	return;
-
-found:
-	/* equivalent of iscsi_data_out_rx_start + _done */
-	conn->rx_buffer = ptr_from_int64(rdmal->sge.addr);
-	conn->rx_size = rdmal->sge.length;
-	task->offset += rdmal->sge.length;
-	task->r2t_count -= rdmal->sge.length;
-	VALGRIND_MAKE_MEM_DEFINED(conn->rx_buffer, conn->rx_size);
-
-	dprintf("itt %x len %u arrived, r2t_count %d\n", (uint32_t) task->tag,
-		rdmal->sge.length, task->r2t_count);
-
-	/*
-	 * We soliticed this data, so hdr->ttt is what we asked for.  Bypass
-	 * data_out_rx_done and just run the task.  If more r2t are needed,
-	 * this will generate them.
-	 */
-	iscsi_scsi_cmd_execute(task);
-
-	conn->rx_task = NULL;
-	conn_read_pdu(conn);
-}
-
-/*
- * Close connection.  There is no device close function.  This is called
- * from iscsi.
- */
-static size_t iscsi_rdma_close(struct iscsi_connection *conn)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	int ret;
-
-	ret = rdma_disconnect(ci->cma_id);
-	if (ret)
-		eprintf("rdma_disconnect: %s\n", strerror(-ret));
-	dprintf("did rdma_disconnect\n");
-	list_del(&ci->conn_tx_ready);
-	list_del(&ci->iser_conn_list);
-	ci->draining = 1;
-	return 0;
-}
-
-/*
- * Called when the connection is freed, from iscsi, but won't do anything until
- * all posted WRs have gone away.  So also called again from RX progress when
- * it notices this happens.
- */
-static void iscsi_rdma_release(struct iscsi_connection *conn)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-	int ret;
-
-	dprintf("conn %p recvl %d\n", ci, ci->recvl_posted);
-
-	ci->freed = 1;
-
-	/* wait until all WRs flushed */
-	if (ci->recvl_posted != 0)
-		return;
-
-	iser_free_comm_login(ci);
-	if (ci->login_phase == LOGIN_PHASE_FF)
-		iser_free_comm(ci);
-
-	/* finally destory QP */
-	ret = ibv_destroy_qp(ci->qp_hndl);
-	if (ret)
-		eprintf("ibv_destroy_qp: %s\n", strerror(-ret));
-
-	/* and free the connection */
-	conn_exit(conn);
-	free(ci);
-}
-
-static int iscsi_rdma_show(struct iscsi_connection *conn, char *buf,
-			   int rest)
-{
-	int ret;
-	char host[NI_MAXHOST];
-	struct conn_info *ci = RDMA_CONN(conn);
-
-	ret = getnameinfo((struct sockaddr *) &ci->peer_addr,
-			  sizeof(ci->peer_addr), host, sizeof(host), NULL, 0,
-			  NI_NUMERICHOST);
-	if (ret) {
-		eprintf("getnameinfo: %m\n");
-		return 0;
-	}
-	return snprintf(buf, rest, "RDMA IP Address: %s", host);
-}
-
-static void iscsi_rdma_event_modify(struct iscsi_connection *conn, int events)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-
-	if (events & EPOLLOUT) {
-		/* with multiple commands queued, may already be on list */
-		if (list_empty(&ci->conn_tx_ready)) {
-			dprintf("tx ready adding %p\n", ci);
-			list_add(&ci->conn_tx_ready, &conn_tx_ready);
-		}
-		tgt_add_sched_event(&ci->tx_sched);
-	} else {
-		dprintf("tx ready removing %p\n", ci);
-		list_del_init(&ci->conn_tx_ready);
-	}
-}
-
-static void *iscsi_rdma_alloc_data_buf(struct iscsi_connection *conn,
-				       size_t sz)
-{
-	struct mempool *mem;
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct iser_device *dev = ci->dev;
-
-	if (list_empty(&dev->mempool_free)) {
-		/* XXX: take slow path: allocate and register */
-		eprintf("free list empty\n");
-		exit(1);
-	}
-
-	if (sz > mempool_size) {
-		eprintf("size %zu too big\n", sz);
-		exit(1);
-	}
-
-	mem = list_entry(dev->mempool_free.next, typeof(*mem), list);
-	list_del(&mem->list);
-	list_add(&mem->list, &dev->mempool_alloc);
-	dprintf("malloc %p sz %zu\n", mem->buf, sz);
-	return mem->buf;
-}
-
-static void iscsi_rdma_free_data_buf(struct iscsi_connection *conn, void *buf)
-{
-	int found = 0;
-	struct mempool *mem;
-	struct conn_info *ci = RDMA_CONN(conn);
-	struct iser_device *dev = ci->dev;
-
-	if (!buf)
-		return;
-	list_for_each_entry(mem, &dev->mempool_alloc, list) {
-		if (mem->buf == buf) {
-			found = 1;
-			break;
-		}
-	}
-	dprintf("free %p\n", mem->buf);
-	if (!found) {
-		eprintf("couldn't locate buf %p\n", buf);
-		exit(1);
-	}
-	list_del(&mem->list);
-	list_add(&mem->list, &dev->mempool_free);
-}
-
-static int iscsi_rdma_getsockname(struct iscsi_connection *conn,
-				  struct sockaddr *sa, socklen_t *len)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-
-	if (*len > sizeof(ci->self_addr))
-		*len = sizeof(ci->self_addr);
-	memcpy(sa, &ci->self_addr, *len);
-	return 0;
-}
-
-static int iscsi_rdma_getpeername(struct iscsi_connection *conn,
-				  struct sockaddr *sa, socklen_t *len)
-{
-	struct conn_info *ci = RDMA_CONN(conn);
-
-	if (*len > sizeof(ci->peer_addr))
-		*len = sizeof(ci->peer_addr);
-	memcpy(sa, &ci->peer_addr, *len);
-	return 0;
-}
-
-static struct iscsi_transport iscsi_iser = {
-	.name			= "iser",
-	.rdma			= 1,
-	.data_padding		= 1,
-	.ep_init		= iscsi_rdma_init,
-	.ep_login_complete	= iscsi_rdma_login_complete,
-	.alloc_task		= iscsi_iser_alloc_task,
-	.free_task		= iscsi_iser_free_task,
-	.ep_read		= iscsi_iser_read,
-	.ep_write_begin		= iscsi_iser_write_begin,
-	.ep_write_end		= iscsi_iser_write_end,
-	.ep_rdma_read		= iscsi_rdma_rdma_read,
-	.ep_rdma_write		= iscsi_rdma_rdma_write,
-	.ep_close		= iscsi_rdma_close,
-	.ep_release		= iscsi_rdma_release,
-	.ep_show		= iscsi_rdma_show,
-	.ep_event_modify	= iscsi_rdma_event_modify,
-	.alloc_data_buf		= iscsi_rdma_alloc_data_buf,
-	.free_data_buf		= iscsi_rdma_free_data_buf,
-	.ep_getsockname		= iscsi_rdma_getsockname,
-	.ep_getpeername		= iscsi_rdma_getpeername,
-};
-
-__attribute__((constructor)) static void iser_transport_init(void)
-{
-	iscsi_transport_register(&iscsi_iser);
-}
-- 
1.7.1

--
To unsubscribe from this list: send the line "unsubscribe stgt" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux SCSI]     [Linux RAID]     [Linux Clusters]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]

  Powered by Linux