[mirror_ubuntu-zesty-kernel.git] / drivers / infiniband / ulp / isert / ib_isert.h

#include <linux/socket.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <rdma/ib_verbs.h>
#include <rdma/rdma_cm.h>
#include <scsi/iser.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 ISCSI_ISER_SG_TABLESIZE		256
#define ISER_FASTREG_LI_WRID		0xffffffffffffffffULL
#define ISER_BEACON_WRID               0xfffffffffffffffeULL

enum isert_desc_type {
	ISCSI_TX_CONTROL,
	ISCSI_TX_DATAIN
};

enum iser_ib_op_code {
	ISER_IB_RECV,
	ISER_IB_SEND,
	ISER_IB_RDMA_WRITE,
	ISER_IB_RDMA_READ,
};

enum iser_conn_state {
	ISER_CONN_INIT,
	ISER_CONN_UP,
	ISER_CONN_FULL_FEATURE,
	ISER_CONN_TERMINATING,
	ISER_CONN_DOWN,
};

struct iser_rx_desc {
	struct iser_ctrl iser_header;
	struct iscsi_hdr iscsi_header;
	char		data[ISER_RECV_DATA_SEG_LEN];
	u64		dma_addr;
	struct ib_sge	rx_sg;
	char		pad[ISER_RX_PAD_SIZE];
} __packed;

struct iser_tx_desc {
	struct iser_ctrl iser_header;
	struct iscsi_hdr iscsi_header;
	enum isert_desc_type type;
	u64		dma_addr;
	struct ib_sge	tx_sg[2];
	int		num_sge;
	struct isert_cmd *isert_cmd;
	struct ib_send_wr send_wr;
} __packed;

enum isert_indicator {
	ISERT_PROTECTED		= 1 << 0,
	ISERT_DATA_KEY_VALID	= 1 << 1,
	ISERT_PROT_KEY_VALID	= 1 << 2,
	ISERT_SIG_KEY_VALID	= 1 << 3,
};

struct pi_context {
	struct ib_mr		       *prot_mr;
	struct ib_mr		       *sig_mr;
};

struct fast_reg_descriptor {
	struct list_head		list;
	struct ib_mr		       *data_mr;
	u8				ind;
	struct pi_context	       *pi_ctx;
};

struct isert_data_buf {
	struct scatterlist     *sg;
	int			nents;
	u32			sg_off;
	u32			len; /* cur_rdma_length */
	u32			offset;
	unsigned int		dma_nents;
	enum dma_data_direction dma_dir;
};

enum {
	DATA = 0,
	PROT = 1,
	SIG = 2,
};

struct isert_rdma_wr {
	struct isert_cmd	*isert_cmd;
	enum iser_ib_op_code	iser_ib_op;
	struct ib_sge		*ib_sge;
	struct ib_sge		s_ib_sge;
	int			rdma_wr_num;
	struct ib_rdma_wr	*rdma_wr;
	struct ib_rdma_wr	s_rdma_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_cmd {
	uint32_t		read_stag;
	uint32_t		write_stag;
	uint64_t		read_va;
	uint64_t		write_va;
	u64			pdu_buf_dma;
	u32			pdu_buf_len;
	struct isert_conn	*conn;
	struct iscsi_cmd	*iscsi_cmd;
	struct iser_tx_desc	tx_desc;
	struct iser_rx_desc	*rx_desc;
	struct isert_rdma_wr	rdma_wr;
	struct work_struct	comp_work;
	struct scatterlist	sg;
};

struct isert_device;

struct isert_conn {
	enum iser_conn_state	state;
	int			post_recv_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;
	struct iser_rx_desc	*rx_descs;
	struct ib_recv_wr	rx_wr[ISERT_QP_MAX_RECV_DTOS];
	struct iscsi_conn	*conn;
	struct list_head	node;
	struct completion	login_comp;
	struct completion	login_req_comp;
	struct iser_tx_desc	login_tx_desc;
	struct rdma_cm_id	*cm_id;
	struct ib_qp		*qp;
	struct isert_device	*device;
	struct mutex		mutex;
	struct completion	wait;
	struct completion	wait_comp_err;
	struct kref		kref;
	struct list_head	fr_pool;
	int			fr_pool_size;
	/* lock to protect fastreg pool */
	spinlock_t		pool_lock;
	struct work_struct	release_work;
	struct ib_recv_wr       beacon;
	bool                    logout_posted;
};

#define ISERT_MAX_CQ 64

/**
 * 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;
	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			refcount;
	struct ib_device	*ib_device;
	struct ib_pd		*pd;
	struct isert_comp	*comps;
	int                     comps_used;
	struct list_head	dev_node;
	int			(*reg_rdma_mem)(struct iscsi_conn *conn,
						    struct iscsi_cmd *cmd,
						    struct isert_rdma_wr *wr);
	void			(*unreg_rdma_mem)(struct isert_cmd *isert_cmd,
						  struct isert_conn *isert_conn);
};

struct isert_np {
	struct iscsi_np         *np;
	struct semaphore	sem;
	struct rdma_cm_id	*cm_id;
	struct mutex		mutex;
	struct list_head	accepted;
	struct list_head	pending;
};
Commit	Line	Data
b8d26b3b NB	1	#include <linux/socket.h>
	2	#include <linux/in.h>
	3	#include <linux/in6.h>
	4	#include <rdma/ib_verbs.h>
	5	#include <rdma/rdma_cm.h>
d3cf81f9 SG	6	#include <scsi/iser.h>
d3cf81f9 SG	7
b8d26b3b	8
24f412dd SG	9	#define DRV_NAME "isert"
	10	#define PFX DRV_NAME ": "
	11
	12	#define isert_dbg(fmt, arg...) \
	13	do { \
	14	if (unlikely(isert_debug_level > 2)) \
	15	printk(KERN_DEBUG PFX "%s: " fmt,\
	16	__func__ , ## arg); \
	17	} while (0)
	18
	19	#define isert_warn(fmt, arg...) \
	20	do { \
	21	if (unlikely(isert_debug_level > 0)) \
	22	pr_warn(PFX "%s: " fmt, \
	23	__func__ , ## arg); \
	24	} while (0)
	25
	26	#define isert_info(fmt, arg...) \
	27	do { \
	28	if (unlikely(isert_debug_level > 1)) \
	29	pr_info(PFX "%s: " fmt, \
	30	__func__ , ## arg); \
	31	} while (0)
	32
	33	#define isert_err(fmt, arg...) \
	34	pr_err(PFX "%s: " fmt, __func__ , ## arg)
	35
59464ef4	36	#define ISCSI_ISER_SG_TABLESIZE 256
9bb4ca68	37	#define ISER_FASTREG_LI_WRID 0xffffffffffffffffULL
bdf20e72	38	#define ISER_BEACON_WRID 0xfffffffffffffffeULL
b8d26b3b NB	39
	40	enum isert_desc_type {
	41	ISCSI_TX_CONTROL,
	42	ISCSI_TX_DATAIN
	43	};
	44
	45	enum iser_ib_op_code {
	46	ISER_IB_RECV,
	47	ISER_IB_SEND,
	48	ISER_IB_RDMA_WRITE,
	49	ISER_IB_RDMA_READ,
	50	};
	51
	52	enum iser_conn_state {
	53	ISER_CONN_INIT,
	54	ISER_CONN_UP,
128e9cc8	55	ISER_CONN_FULL_FEATURE,
b8d26b3b NB	56	ISER_CONN_TERMINATING,
	57	ISER_CONN_DOWN,
	58	};
	59
	60	struct iser_rx_desc {
d3cf81f9	61	struct iser_ctrl iser_header;
b8d26b3b NB	62	struct iscsi_hdr iscsi_header;
	63	char data[ISER_RECV_DATA_SEG_LEN];
	64	u64 dma_addr;
	65	struct ib_sge rx_sg;
	66	char pad[ISER_RX_PAD_SIZE];
	67	} __packed;
	68
	69	struct iser_tx_desc {
d3cf81f9	70	struct iser_ctrl iser_header;
b8d26b3b NB	71	struct iscsi_hdr iscsi_header;
	72	enum isert_desc_type type;
	73	u64 dma_addr;
	74	struct ib_sge tx_sg[2];
	75	int num_sge;
	76	struct isert_cmd *isert_cmd;
	77	struct ib_send_wr send_wr;
	78	} __packed;
	79
d3e125da SG	80	enum isert_indicator {
	81	ISERT_PROTECTED = 1 << 0,
	82	ISERT_DATA_KEY_VALID = 1 << 1,
	83	ISERT_PROT_KEY_VALID = 1 << 2,
	84	ISERT_SIG_KEY_VALID = 1 << 3,
	85	};
	86
	87	struct pi_context {
	88	struct ib_mr *prot_mr;
d3e125da SG	89	struct ib_mr *sig_mr;
	90	};
	91
59464ef4	92	struct fast_reg_descriptor {
d3e125da SG	93	struct list_head list;
d3e125da SG	94	struct ib_mr *data_mr;
d3e125da SG	95	u8 ind;
d3e125da SG	96	struct pi_context *pi_ctx;
59464ef4 VP	97	};
59464ef4 VP	98
e3d7e4c3 SG	99	struct isert_data_buf {
	100	struct scatterlist *sg;
	101	int nents;
	102	u32 sg_off;
	103	u32 len; /* cur_rdma_length */
	104	u32 offset;
	105	unsigned int dma_nents;
	106	enum dma_data_direction dma_dir;
	107	};
	108
570db170 SG	109	enum {
	110	DATA = 0,
	111	PROT = 1,
	112	SIG = 2,
	113	};
	114
b8d26b3b	115	struct isert_rdma_wr {
b8d26b3b NB	116	struct isert_cmd *isert_cmd;
	117	enum iser_ib_op_code iser_ib_op;
	118	struct ib_sge *ib_sge;
59464ef4	119	struct ib_sge s_ib_sge;
e622f2f4 CH	120	int rdma_wr_num;
	121	struct ib_rdma_wr *rdma_wr;
	122	struct ib_rdma_wr s_rdma_wr;
570db170	123	struct ib_sge ib_sg[3];
e3d7e4c3	124	struct isert_data_buf data;
9e961ae7	125	struct isert_data_buf prot;
59464ef4	126	struct fast_reg_descriptor *fr_desc;
b8d26b3b NB	127	};
	128
	129	struct isert_cmd {
	130	uint32_t read_stag;
	131	uint32_t write_stag;
	132	uint64_t read_va;
	133	uint64_t write_va;
dbbc5d11 NB	134	u64 pdu_buf_dma;
dbbc5d11 NB	135	u32 pdu_buf_len;
b8d26b3b	136	struct isert_conn *conn;
d703ce2f	137	struct iscsi_cmd *iscsi_cmd;
b8d26b3b	138	struct iser_tx_desc tx_desc;
4366b19c	139	struct iser_rx_desc *rx_desc;
b8d26b3b NB	140	struct isert_rdma_wr rdma_wr;
b8d26b3b NB	141	struct work_struct comp_work;
9fd60088	142	struct scatterlist sg;
b8d26b3b NB	143	};
	144
	145	struct isert_device;
	146
	147	struct isert_conn {
	148	enum iser_conn_state state;
b8d26b3b	149	int post_recv_buf_count;
b8d26b3b NB	150	u32 responder_resources;
b8d26b3b NB	151	u32 initiator_depth;
23a548ee	152	bool pi_support;
b8d26b3b NB	153	u32 max_sge;
	154	char *login_buf;
	155	char *login_req_buf;
	156	char *login_rsp_buf;
	157	u64 login_req_dma;
2371e5da	158	int login_req_len;
b8d26b3b	159	u64 login_rsp_dma;
dac6ab30	160	struct iser_rx_desc *rx_descs;
4366b19c	161	struct ib_recv_wr rx_wr[ISERT_QP_MAX_RECV_DTOS];
b8d26b3b	162	struct iscsi_conn *conn;
bd379220	163	struct list_head node;
dac6ab30	164	struct completion login_comp;
2371e5da	165	struct completion login_req_comp;
dac6ab30 SG	166	struct iser_tx_desc login_tx_desc;
	167	struct rdma_cm_id *cm_id;
	168	struct ib_qp *qp;
	169	struct isert_device *device;
	170	struct mutex mutex;
	171	struct completion wait;
	172	struct completion wait_comp_err;
	173	struct kref kref;
	174	struct list_head fr_pool;
	175	int fr_pool_size;
a3a5a826	176	/* lock to protect fastreg pool */
dac6ab30	177	spinlock_t pool_lock;
b02efbfc	178	struct work_struct release_work;
bdf20e72	179	struct ib_recv_wr beacon;
991bb764	180	bool logout_posted;
b8d26b3b NB	181	};
	182
	183	#define ISERT_MAX_CQ 64
	184
4a295bae SG	185	/**
	186	* struct isert_comp - iSER completion context
	187	*
	188	* @device: pointer to device handle
6f0fae3d	189	* @cq: completion queue
36ea63b5	190	* @wcs: work completion array
4a295bae SG	191	* @active_qps: Number of active QPs attached
4a295bae SG	192	* to completion context
6f0fae3d	193	* @work: completion work handle
4a295bae SG	194	*/
4a295bae SG	195	struct isert_comp {
6f0fae3d SG	196	struct isert_device *device;
6f0fae3d SG	197	struct ib_cq *cq;
36ea63b5	198	struct ib_wc wcs[16];
4a295bae	199	int active_qps;
6f0fae3d	200	struct work_struct work;
b8d26b3b NB	201	};
	202
	203	struct isert_device {
a3a5a826	204	int use_fastreg;
d3e125da	205	bool pi_capable;
b8d26b3b	206	int refcount;
b8d26b3b	207	struct ib_device *ib_device;
67cb3949	208	struct ib_pd *pd;
4a295bae SG	209	struct isert_comp *comps;
4a295bae SG	210	int comps_used;
b8d26b3b	211	struct list_head dev_node;
d40945d8 VP	212	int (reg_rdma_mem)(struct iscsi_conn conn,
	213	struct iscsi_cmd *cmd,
	214	struct isert_rdma_wr *wr);
	215	void (unreg_rdma_mem)(struct isert_cmd isert_cmd,
	216	struct isert_conn *isert_conn);
b8d26b3b NB	217	};
	218
	219	struct isert_np {
ca6c1d82	220	struct iscsi_np *np;
ed8cb0a4 JD	221	struct semaphore sem;
	222	struct rdma_cm_id *cm_id;
	223	struct mutex mutex;
bd379220 JD	224	struct list_head accepted;
bd379220 JD	225	struct list_head pending;
b8d26b3b	226	};