Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

#include <rdma/ib_verbs.h>

#include <rdma/rdma_cm.h>

#define DRV_NAME	"isert"

#define PFX		DRV_NAME ": "

#define isert_dbg(fmt, arg...)				 \

	do {						 \

		if (unlikely(isert_debug_level > 2))	 \

			printk(KERN_DEBUG PFX "%s: " fmt,\

				__func__ , ## arg);	 \

	} while (0)

#define isert_warn(fmt, arg...)				\

	do {						\

		if (unlikely(isert_debug_level > 0))	\

			pr_warn(PFX "%s: " fmt,         \

				__func__ , ## arg);	\

	} while (0)

#define isert_info(fmt, arg...)				\

	do {						\

		if (unlikely(isert_debug_level > 1))	\

			pr_info(PFX "%s: " fmt,         \

				__func__ , ## arg);	\

	} while (0)

#define isert_err(fmt, arg...) \

	pr_err(PFX "%s: " fmt, __func__ , ## arg)

#define ISERT_RDMA_LISTEN_BACKLOG	10

#define ISCSI_ISER_SG_TABLESIZE		256

#define ISER_FASTREG_LI_WRID		0xffffffffffffffffULL

#define ISER_BEACON_WRID               0xfffffffffffffffeULL

enum isert_desc_type {

	ISCSI_TX_CONTROL,

enum iser_conn_state {

	ISER_CONN_INIT,

	ISER_CONN_UP,

	ISER_CONN_FULL_FEATURE,

	ISER_CONN_TERMINATING,

	ISER_CONN_DOWN,

};

	struct ib_sge	tx_sg[2];

	int		num_sge;

	struct isert_cmd *isert_cmd;

	struct llist_node *comp_llnode_batch;

	struct llist_node comp_llnode;

	bool		llnode_active;

	struct ib_send_wr send_wr;

} __packed;

	enum dma_data_direction dma_dir;

};

enum {

	DATA = 0,

	PROT = 1,

	SIG = 2,

};

struct isert_rdma_wr {

	struct list_head	wr_list;

	struct isert_cmd	*isert_cmd;

	int			send_wr_num;

	struct ib_send_wr	*send_wr;

	struct ib_send_wr	s_send_wr;

	struct ib_sge		ib_sg[3];

	struct isert_data_buf	data;

	struct isert_data_buf	prot;

	struct fast_reg_descriptor *fr_desc;

struct isert_conn {

	enum iser_conn_state	state;

	int			post_recv_buf_count;

	atomic_t		post_send_buf_count;

	u32			responder_resources;

	u32			initiator_depth;

	bool			pi_support;

	u32			max_sge;

	char			*login_buf;

	char			*login_req_buf;

	char			*login_rsp_buf;

	u64			login_req_dma;

	int			login_req_len;

	u64			login_rsp_dma;

	unsigned int		conn_rx_desc_head;

	struct iser_rx_desc	*conn_rx_descs;

	struct iscsi_conn	*conn;

	struct list_head	conn_accept_node;

	struct completion	conn_login_comp;

	struct completion	login_req_comp;

	struct iser_tx_desc	conn_login_tx_desc;

	struct rdma_cm_id	*conn_cm_id;

	struct ib_pd		*conn_pd;

	struct ib_mr		*conn_mr;

	struct ib_qp		*conn_qp;

	struct isert_device	*conn_device;

	struct work_struct	conn_logout_work;

	struct mutex		conn_mutex;

	struct completion	conn_wait;

	struct completion	conn_wait_comp_err;

	int			conn_fr_pool_size;

	/* lock to protect fastreg pool */

	spinlock_t		conn_lock;

#define ISERT_COMP_BATCH_COUNT	8

	int			conn_comp_batch;

	struct llist_head	conn_comp_llist;

	bool                    disconnect;

	struct work_struct	release_work;

	struct ib_recv_wr       beacon;

	bool                    logout_posted;

};

#define ISERT_MAX_CQ 64

struct isert_cq_desc {

/**

 * struct isert_comp - iSER completion context

 *

 * @device:     pointer to device handle

 * @cq:         completion queue

 * @wcs:        work completion array

 * @active_qps: Number of active QPs attached

 *              to completion context

 * @work:       completion work handle

 */

struct isert_comp {

	struct isert_device     *device;

	int			cq_index;

	struct work_struct	cq_rx_work;

	struct work_struct	cq_tx_work;

	struct ib_cq		*cq;

	struct ib_wc		 wcs[16];

	int                      active_qps;

	struct work_struct	 work;

};

struct isert_device {

	int			use_fastreg;

	bool			pi_capable;

	int			cqs_used;

	int			refcount;

	int			cq_active_qps[ISERT_MAX_CQ];

	struct ib_device	*ib_device;

	struct ib_cq		*dev_rx_cq[ISERT_MAX_CQ];

	struct ib_cq		*dev_tx_cq[ISERT_MAX_CQ];

	struct isert_cq_desc	*cq_desc;

	struct isert_comp	*comps;

	int                     comps_used;

	struct list_head	dev_node;

	struct ib_device_attr	dev_attr;

	int			(*reg_rdma_mem)(struct iscsi_conn *conn,

};

struct isert_np {

	struct iscsi_np         *np;

	struct semaphore	np_sem;

	struct rdma_cm_id	*np_cm_id;

	struct mutex		np_accept_mutex;

	return ret;

r2t_out:

	iscsit_unregister_transport(&iscsi_target_transport);

	kmem_cache_destroy(lio_r2t_cache);

ooo_out:

	kmem_cache_destroy(lio_ooo_cache);

	void			*np_context;

	struct iscsit_transport *np_transport;

	struct list_head	np_list;

	struct iscsi_tpg_np	*tpg_np;

} ____cacheline_aligned;

struct iscsi_tpg_np {

{

	struct iscsi_session *sess = NULL;

	struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf;

	enum target_prot_op sup_pro_ops;

	int ret;

	sess = kzalloc(sizeof(struct iscsi_session), GFP_KERNEL);

		kfree(sess);

		return -ENOMEM;

	}

	sup_pro_ops = conn->conn_transport->iscsit_get_sup_prot_ops(conn);

	sess->se_sess = transport_init_session(sup_pro_ops);

	sess->se_sess = transport_init_session(TARGET_PROT_NORMAL);

	if (IS_ERR(sess->se_sess)) {

		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,

				ISCSI_LOGIN_STATUS_NO_RESOURCES);

	}

	kfree(conn->sess->sess_ops);

	kfree(conn->sess);

	conn->sess = NULL;

old_sess_out:

	iscsi_stop_login_thread_timer(np);

		conn->sock = NULL;

	}

	if (conn->conn_transport->iscsit_wait_conn)

		conn->conn_transport->iscsit_wait_conn(conn);

	if (conn->conn_transport->iscsit_free_conn)

		conn->conn_transport->iscsit_free_conn(conn);

	}

	login->zero_tsih = zero_tsih;

	conn->sess->se_sess->sup_prot_ops =

		conn->conn_transport->iscsit_get_sup_prot_ops(conn);

	tpg = conn->tpg;

	if (!tpg) {

		pr_err("Unable to locate struct iscsi_conn->tpg\n");